/* t1 - vector */
auto t1_i = 3, t1_j = 3, t1_k, t1_r[];
auto t1_m[]	= {  0,  0,  0,  0 };
int32_t t1_l0[]	= {  0,  1,  2,  3 };
int32_t t1_l1[]	= {  4,  5,  6,  7 };
int32_t t1_l2[]	= {  8,  9, 10, 11 };
int32_t t1_l3[]	= { 12, 13, 14, 15 };
t1_m[0] = t1_l0;
t1_m[1] = t1_l1;
t1_m[2] = t1_l2;
t1_m[3] = t1_l3;
for (t1_k = 0; t1_k < 10; ++t1_k)
    t1_r = t1_m[t1_i],  t1_r = t1_r[t1_j];
void t1() {
    auto i = 3, j = 3, k, r[];
    auto m[]	 = {  0,  0,  0,  0 };
    int32_t l0[] = {  0,  1,  2,  3 };
    int32_t l1[] = {  4,  5,  6,  7 };
    int32_t l2[] = {  8,  9, 10, 11 };
    int32_t l3[] = { 12, 13, 14, 15 };
    m[0] = l0;
    m[1] = l1;
    m[2] = l2;
    m[3] = l3;
    for (k = 0; k < 10; ++k)
	r = m[i],  r = r[j];
}
t1();

/* t2 - function reference */
function_t t2_ft;
void
t2_t(x, y)
{
    print("t(%d, %d)\n", x, y);
}
t2_t(1, 2);
t2_ft = &t2_t;
(*t2_ft)(3, 4);
function_t t2_fp = &print;
void
t2_tp(function_t p, x, y)
{
    (*p)("tp(%d, %d)\n", x, y);
}
function_t t2_ftp = &t2_tp;
t2_tp(&print, 5, 6);
(*t2_ftp)(t2_fp, 7, 8);
void t2() {
    function_t ft;
    t2_t(1, 2);
    ft = &t2_t;
    (*ft)(3, 4);
    function_t fp = &print;
    function_t ftp = &t2_tp;
    t2_tp(&print, 5, 6);
    (*ftp)(fp, 7, 8);
}
t2();

/* t3 - goto */
void
t3_test()
{
    auto n = 10;
a:
    if (n < 0)
	goto d;
b:
    --n;
c:
    if (n > 0)
	goto a;
    print("n = %d\n", n);
    goto e;
d:
    print("oops\n");
    if (false) {
    e:
	print("ok\n");
    }
}
t3_test();
print("should goto work on toplevel?\n");
goto t3_x;
if (null) {
    t3_x:
    print("why not?\n");
}
else
    print("probably not\n");

/* t4 - record */
struct t4_types {
    int8_t	s8;
    uint8_t	u8;
    int16_t	s16;
    uint16_t	u16;
    int32_t	s32;
    uint32_t	u32;
    int64_t	s64;
    uint64_t	u64;
    float32_t	f32;
    float64_t	f64;
    auto	any;
};
t4_types t4_t = {
    254, 254,
    65534, 65534,
    0xfffffffe, 0xfffffffe,
    0xfffffffffffffffe, 0xfffffffffffffffe,
    3.14, 3.14,
    true
};
print("\
s8:	%d		u8:	%d\n\
s16:	%d		u16:	%d\n\
s32:	%d		u32:	%d\n\
s64:	%d		u64:	%d\n\
f32:	%f	f64:	%f\n\
any:	%d\n",
      t4_t.s8, t4_t.u8,
      t4_t.s16, t4_t.u16,
      t4_t.s32, t4_t.u32,
      t4_t.s64, t4_t.u64,
      t4_t.f32, t4_t.f64,
      t4_t.any);
void
t4_test()
{
    auto	n = -1;
    auto	d = 7/3.0;
    t4_types t = {
	n, n,
	n, n,
	n, n,
	n, n,
	d, d,
	"string"
    };
    print("\
s8:	%d		u8:	%d\n\
s16:	%d		u16:	%d\n\
s32:	%d		u32:	%d\n\
s64:	%d		u64:	%d\n\
f32:	%f	f64:	%f\n\
any:	%s\n",
	  t.s8, t.u8,
	  t.s16, t.u16,
	  t.s32, t.u32,
	  t.s64, t.u64,
	  t.f32, t.f64,
	  t.any);
}
t4_test();
struct t4_rect {
    int32_t	x, y;
    uint32_t	w, h;
};
struct t4_window {
    t4_rect	r;
    t4_window	parent;
    t4_window	children[];
};
t4_window t4_wc1 = {
    {
	5, 5,
	10, 10,
    },
    null, null
};
t4_window t4_wc2 = {
    {
	15, 15,
	10, 10,
    },
    null, null
};
auto t4_width = 640, t4_height = 480;
t4_window t4_w = {
    {
	0, 0,
	t4_width, t4_height,
    },
    null,
    { t4_wc1, t4_wc2 },
};
t4_wc1.parent = t4_wc2.parent = t4_w;
print("t4_w.r.x = %d - t4_w.r.y = %d - t4_w.r.w = %d - t4_w.r.h = %d\n",
      t4_w.r.x, t4_w.r.y, t4_w.r.w, t4_w.r.h);
print("t4_w.children[0].r.x = %d - t4_w.children[0].r.y = %d\n\
t4_w.children[0].r.w = %d - t4_w.children[0].r.h = %d\n",
      t4_w.children[0].r.x, t4_w.children[0].r.y,
      t4_w.children[0].r.w, t4_w.children[0].r.h);
print("t4_w.children[1].r.x = %d - t4_w.children[1].r.y = %d\n\
t4_w.children[1].r.w = %d - t4_w.children[1].r.h = %d\n",
      t4_w.children[1].r.x, t4_w.children[1].r.y,
      t4_w.children[1].r.w, t4_w.children[1].r.h);
void
t4_test2()
{
    print("\n");
    t4_window wc1 = {
	{
	    25, 25,
	    10, 10,
	},
	null, null
    };
    t4_window wc2 = {
	{
	    35, 35,
	    10, 10,
	},
	null, null
    };
    auto width = 800, height = 600;
    t4_window w = {
	{
	    100, 100,
	    width, height,
	},
	null,
	{ wc1, wc2 },
    };
    wc1.parent = wc2.parent = w;
    print("w.r.x = %d - w.r.y = %d - w.r.w = %d - w.r.h = %d\n",
	  w.r.x, w.r.y, w.r.w, w.r.h);
    print("w.children[0].r.x = %d - w.children[0].r.y = %d\n\
w.children[0].r.w = %d - w.children[0].r.h = %d\n",
	  w.children[0].r.x, w.children[0].r.y,
	  w.children[0].r.w, w.children[0].r.h);
    print("w.children[1].r.x = %d - w.children[1].r.y = %d\n\
w.children[1].r.w = %d - w.children[1].r.h = %d\n",
	  w.children[1].r.x, w.children[1].r.y,
	  w.children[1].r.w, w.children[1].r.h);
}
t4_test2();

/* t5 - record */
struct t5_user_t { name, age; };
t5_user_t t5_user = new(t5_user_t);
t5_user.name = "john";
t5_user.age = 25;
print("%s %d\n", t5_user.name, t5_user.age);
void t5_test(t5_user_t user)
{
    print("%s %d\n", user.name, user.age);
}
struct t5_types {
    int8_t	s8;
    uint8_t	u8;
    int16_t	s16;
    uint16_t	u16;
    int32_t	s32;
    uint32_t	u32;
    int64_t	s64;
    uint64_t	u64;
    float32_t	f32;
    float64_t	f64;
    auto	any;
};
t5_types t5_t = new(t5_types);
t5_t.s8 = t5_t.u8 = 0xfe;
t5_t.s16 = t5_t.u16 = 0xfffe;
t5_t.s32 = t5_t.u32 = 0xfffffffe;
t5_t.s64 = -2;
t5_t.u64 = 0xfffffffffffffffe;
t5_t.f32 = t5_t.f64 = 3/7.0;
t5_t.any = "string";
print("\
s8 : %d\n\
u8 : %d\n\
s16: %d\n\
u16: %d\n\
s32: %d\n\
u32: %d\n\
s64: %d\n\
u64: %d\n\
f32: %f\n\
f64: %f\n\
any: %s\n\
", t5_t.s8, t5_t.u8, t5_t.s16, t5_t.u16, t5_t.s32, t5_t.u32,
      t5_t.s64, t5_t.u64, t5_t.f32, t5_t.f64, t5_t.any);

/* t6 - reference */
function_t t6_p = &print;
(*t6_p)("from p: %d\n", 1);
auto t6_a = 10;
auto *t6_b = &t6_a;
print("t6_a: %d -> ", t6_a);
*t6_b = 20;
print("%d (%d)\n", *t6_b, t6_a);
void t6_test1(void)
{
    auto a = 10;
    auto *b = &a;
    print("a: %d -> ", a);
    *b = 20;
    print("%d (%d)\n", *b, a);
}
t6_test1();
void t6_test2(*b)
{
    *b = 1;
}
void t6_test3(a)
{
    print("a: %d -> ", a);
    t6_test2(&a);
    print("%d\n", a);
}
t6_test3(t6_a);
print("a: %d\n", t6_a);
t6_p = &t6_test2;
(*t6_p)(&t6_a);
print("t6_a: %d\n", t6_a);

/* test7 - vector */
auto t7_i = 3, t7_j = 3, t7_k, t7_r;
int32_t t7_m[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
for (t7_k = 0; t7_k < 100; ++t7_k)
	t7_r = t7_m[t7_i * 4 + t7_j];
void test7()
{
    auto i = 3, j = 3, k, r;
    int32_t m[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
    for (k = 0; k < 100; ++k)
	    r = m[i * 4 + j];
}
test7();

/* test8 - switch */
auto t8_i = 1;
auto t8_j = 0;
/* produce a vswitch with 2 entries */
switch (t8_i) {
    case 0:	t8_j = 1;	print("error %d\n", __LINE__);	break;
    case 1:	t8_j = 1;					break;
    default:	t8_j = 1;	print("error %d\n", __LINE__);	break;
}
if (t8_j == 0)
    print("error %d\n", __LINE__);
t8_j = -1;
/* produce a hswitch because 0 and 512 clash */
switch (t8_i - 512) {
    case 0:	t8_j = 1;	print("error %d\n", __LINE__);	break;
    case 512:	t8_j = 1;	print("error %d\n", __LINE__);	break;
    case -511:	t8_j = 0;					break;
}
if (t8_j)
    print("error %d\n", __LINE__);
t8_j = 1;
/* produce a vsitch with 1 entry */
switch (t8_i << 1) {
    default:	t8_j = 0;					break;
    case 22:	t8_j = 0;	print("error %d\n", __LINE__);	break;
}
if (t8_j)
    print("error %d\n", __LINE__);
/* this checks that the fallback value is correct,
 * by producing a vswitch with only one fallback, and matching it */
t8_j = 1;
switch (t8_i) {
    case 0:	t8_j = 0;	print("error %d\n", __LINE__);	break;
    case 2:	t8_j = 0;	print("error %d\n", __LINE__);	break;
    case 3:	t8_j = 0;	print("error %d\n", __LINE__);	break;
}
/* same test, but now with a default entry */
t8_j = -1;
switch (t8_i) {
    case 0:	t8_j = 0;	print("error %d\n", __LINE__);	break;
    default:	t8_j = 1;					break;
    case 2:	t8_j = 0;	print("error %d\n", __LINE__);	break;
    case 3:	t8_j = 0;	print("error %d\n", __LINE__);	break;
}
/* generate a case where there would be no clashes, but still
 * need to generate a hash table due to range of values, i.e.
 * if all values were actually tested, then a clash would exist */
t8_j = 1;
switch (t8_i) {
    case 0:	t8_j = 0;	print("error %d\n", __LINE__);	break;
    case 3:	t8_j = 0;	print("error %d\n", __LINE__);	break;
}
/* same test, but now with a default entry */
t8_j = -1;
switch (t8_i) {
    default:	t8_j = 1;					break;
    case 3:	t8_j = 0;	print("error %d\n", __LINE__);	break;
}

/* test9 - generic */
auto t9_fact(auto n);
auto
t9_fact(auto n)
{
    auto r;
    for (r = 1; n > 1; --n)
	r *= n;
    return r;
}
void
t9(n, c)
{
    for (; c > 0; --c)
	print("%d %d %d\n", n, c, t9_fact(n));
}
t9(17, 10);

/* test10 - typedef */
typedef float64_t t10_f64_t, t10_matrix[4][4], *t10_pf64_t,
    (*t10_ff64_t)(float64_t number);
auto t10_f64v;
t10_f64v = 7/3.0;
print("t10_f64v = %f - ", t10_f64v);
t10_pf64_t t10_f64r = &t10_f64v;
print("*t10_f64r = %f\n", *t10_f64r);
*t10_f64r = 1.0;
print("t10_f64v = %f - *t10_f64r = %f\n", t10_f64v, *t10_f64r);
auto
t10_print_float64(float64_t number)
{
    print("%f", number);
    return number;
}
t10_ff64_t t10_fp = &t10_print_float64;
t10_matrix t10_m = {
    { 1, 0, 0, 0, },
    { 0, 1, 0, 0, },
    { 0, 0, 1, 0, },
    { 0, 0, 0, 1, },
};
auto t10_i, t10_j;
for (t10_i = 0; t10_i < 4; ++t10_i) {
    print("{ ");
    for (t10_j = 0; t10_j < 4; ++t10_j) {
	*t10_f64r = (*t10_fp)(t10_m[t10_i][t10_j]);
	print("(%f) ", *t10_f64r);
    }
    print("}\n");
}
void t10() {
    auto f64v;
    f64v = 7/3.0;
    print("f64v = %f - ", f64v);
    t10_pf64_t f64r = &f64v;
    print("*f64r = %f\n", *f64r);
    *f64r = 1.0;
    print("f64v = %f - *f64r = %f\n", f64v, *f64r);
    t10_ff64_t fp = &t10_print_float64;
    t10_matrix m = {
	{ 1, 0, 0, 0, },
	{ 0, 1, 0, 0, },
	{ 0, 0, 1, 0, },
	{ 0, 0, 0, 1, },
    };
    auto i, j;
    for (i = 0; i < 4; ++i) {
	print("{ ");
	for (j = 0; j < 4; ++j) {
	    *f64r = (*fp)(m[i][j]);
	    print("(%f) ", *f64r);
	}
	print("}\n");
    }
}
t10();

/* test11 - vector */
auto t11_i = 2;
auto t11_data[] = {
             1,			 t11_i * 2, 3,
    t11_i << 3,				 5, t11_i & 3,
             7, t11_i * t11_i * t11_i * 10, 9
};
for (t11_i = 0; t11_i < 9; ++t11_i)
    print("t11_data[%d] = %d\n", t11_i, t11_data[t11_i]);
int8_t t11_str[] = "a string";
print("t11_str = \"%s\"\n", t11_str);
for (t11_i = 0; t11_i < 8; ++t11_i)
    print("t11_str[%d] = '%c'\n", t11_i, t11_str[t11_i]);
void
t11_test(void)
{
    t11_i = 3;
    auto t[] = { t11_i * 2, 2, t11_i * 4, 4, t11_i * 6, 6 };
    for (t11_i = 0; t11_i < 6; ++t11_i)
	print("t[%d] = %d\n", t11_i, t[t11_i]);
}
t11_test();
t11_i = 10;
int32_t t11_idata[] = { 1, 2.3, t11_i * 10, 6 };
print("{ %d, %d, %d, %d }\n", t11_idata[0], t11_idata[1],
      t11_idata[2], t11_idata[3]);
void t11() {
    auto i = 10;
    int32_t idata[] = { 1, 2.3, i * 10, 6 };
    print("{ %d, %d, %d, %d }\n", idata[0], idata[1], idata[2], idata[3]);
}
t11();

/* test12 - vector */
auto t12_i = 10, t12_j = 5;
float64_t t12_m[4][4] = {
    {         1,     0,     0, t12_j * 2 },
    {         0,     1, t12_i, 0 },
    {         0, t12_j,     1, 0 },
    { t12_i * 2,     0,     0, 1 },
};
for (t12_i = 0; t12_i < 4; ++t12_i) {
    print("{ ");
    for (t12_j = 0; t12_j < 4; ++t12_j)
	print("%4f ", t12_m[t12_i][t12_j]);
    print("}\n");
}
print("-\n");
for (t12_i = 0; t12_i < 4; ++t12_i) {
    print("{ ");
    for (t12_j = 0; t12_j < 4; ++t12_j) {
	//print("%f ", m[i][j] = i * 10 + j);
	/* Currently, and probably a "feature", is that the "implicit"
	 * value is not coerced on assignments, in this case would
	 * have been a promotion, but the idea is that on complex
	 * expressions, there is no implicit coercion for assignments
	 */
	t12_m[t12_i][t12_j] = (t12_i + 1) * 10 + t12_j + 1;
	print("%f ", t12_m[t12_i][t12_j]);
    }
    print("}\n");
}
t12_i = 10, t12_j = 5;
print("-\n");
int16_t t12_n[4][] = {
    { t12_j * 2,     0,     0, 1 },
    {         0, t12_i,     1, 0 },
    {         0,     1, t12_j, 0 },
    {         1,     0,     0, t12_i * 2 },
};
for (t12_i = 0; t12_i < 4; ++t12_i) {
    print("{ ");
    for (t12_j = 0; t12_j < 4; ++t12_j)
	print("%2d ", t12_n[t12_i][t12_j]);
    print("}\n");
}
print("-\n");
int16_t t12_k[];
for (t12_i = 0; t12_i < 4; t12_i++) {
    t12_k = t12_n[t12_i];
    print("{ ");
    for (t12_j = 0; t12_j < 4; ++t12_j)
	print("%2d ", t12_k[t12_j]);
    print("}\n");
}
print("-\n");
for (t12_i = 0; t12_i < 4; t12_i++) {
    t12_k = t12_n[t12_i];
    print("{ ");
    for (t12_j = 0; t12_j < 4; ++t12_j) {
	t12_k[t12_j] = (t12_i + 1) * 10 + t12_j + 1;
	print("%d ", t12_k[t12_j]);
    }
    print("}\n");
}
uint8_t t12_s[2][6] = {
    { "foobar" },
    { 'b', 'l', 'a', 'b', 'l', 'a', },
};
print("-\n");
for (t12_i = 0; t12_i < 2; ++t12_i)
    for (t12_j = 0; t12_j < 6; ++t12_j)
	print("%c", t12_s[t12_i][t12_j]);
print("%s\n", t12_s);
uint8_t t12_t[2][] = {
    { "foobar" },
    { 'b', 'l', 'a', 'b', 'l', 'a', },
};
print("-\n");
for (t12_i = 0; t12_i < 2; ++t12_i)
    for (t12_j = 0; t12_j < 6; ++t12_j)
	print("%c", t12_t[t12_i][t12_j]);
print("%s%s\n", t12_t[0], t12_t[1]);
void t12()
{
    print("-\n");
    auto i = 10, j = 5;
    int32_t m[4][4] = {
	{     1, 0, 0, j * 2 },
	{     0, 1, j, 0 },
	{     0, i, 1, 0 },
	{ i * 2, 0, 0, 1 },
    };
    for (i = 0; i < 4; ++i) {
	print("{ ");
	for (j = 0; j < 4; ++j)
	    print("%2d ", m[i][j]);
	print("}\n");
    }
    print("-\n");
    for (i = 0; i < 4; ++i) {
	print("{ ");
	for (j = 0; j < 4; ++j) {
	    //print("%f ", m[i][j] = i * 10 + j);
	    m[i][j] = (i + 1) * 10 + j + 1;
	    print("%d ", m[i][j]);
	}
	print("}\n");
    }
    i = 10, j = 5;
    print("-\n");
    float32_t n[4][] = {
	{ i * 2, 0, 0, 1 },
	{     0, j, 1, 0 },
	{     0, 1, i, 0 },
	{     1, 0, 0, j * 2 },
    };
    for (i = 0; i < 4; ++i) {
	print("{ ");
	for (j = 0; j < 4; ++j)
	    print("%4f ", n[i][j]);
	print("}\n");
    }
    print("-\n");
    float32_t k[];
    for (i = 0; i < 4; i++) {
	k = n[i];
	print("{ ");
	for (j = 0; j < 4; ++j)
	    print("%4f ", k[j]);
	print("}\n");
    }
    print("-\n");
    for (i = 0; i < 4; i++) {
	k = n[i];
	print("{ ");
	for (j = 0; j < 4; ++j) {
	    k[j] = (i + 1) * 10 + j + 1;
	    print("%f ", k[j]);
	}
	print("}\n");
    }
    uint8_t s[2][6] = {
	{ "foobar" },
	{ 'b', 'l', 'a', 'b', 'l', 'a', },
    };
    print("-\n");
    for (i = 0; i < 2; ++i)
	for (j = 0; j < 6; ++j)
	    print("%c", s[i][j]);
    print("%s\n", s);
    uint8_t t[2][] = {
	{ "foobar" },
	{ 'b', 'l', 'a', 'b', 'l', 'a', },
    };
    print("-\n");
    for (i = 0; i < 2; ++i)
	for (j = 0; j < 6; ++j)
	    print("%c", t[i][j]);
    print("%s%s\n", t[0], t[1]);
}
t12();

/* test13 - generic */
auto t13_i = 0, t13_j = 1, t13_k = 2;
if (t13_i && t13_j && t13_k)			print("13ops\n");
if (t13_i || t13_j || t13_k) /*nothing*/; else	print("13ops\n");
if (!(t13_i && t13_j && t13_k))/*nothing*/;else	print("13ops\n");
if (!(t13_i || t13_j || t13_k))			print("13ops\n");
t13_i ? print("13ops\n") : t13_j ? true : print("13ops\n");
!t13_j ? print("13ops\n") : t13_i ? print("13ops\n") : t13_k ? true : print("13ops\n");
(((t13_j))) ? true : print("13ops\n");
;;;
if ((t13_j %= t13_k) != 1)			print("13ops\n");
if ((t13_i /= t13_j) != 0)			print("13ops\n");
if (!t13_i != t13_j)				print("13ops\n");
if (!(t13_i == t13_j))/*nothing*/;else		print("13ops\n");
if (t13_j < t13_i)				print("13ops\n");
if (t13_j <= t13_i)				print("13ops\n");
if (t13_j == t13_i)				print("13ops\n");
if (t13_j >= t13_k)				print("13ops\n");
if (t13_j > t13_k)				print("13ops\n");
if (t13_k >>> 1 != t13_j)			print("13ops\n");
if (t13_j >>> 1 != t13_i)			print("13ops\n");
if ((1 << t13_j) != t13_k)			print("13ops\n");
if (~t13_i != -t13_j)				print("13ops\n");
/*   Adding a function call version -- this test actually triggered a
 * bug in the ssa naming code, that would not happen if variables
 * were not global, but some other different bug may trigger in the
 * future, so add a callable function test also.
 *   This test in interesting for optimization, because, assuming the optimizer
 * consider that 'print' may modify any global variable, every pass of
 * constant propagation and constant folding will remove one 'print' call
 * due to dead code elimination, what allows it to constant propagate and
 * constant fold the next statement, and so on.
 *   Another interesting detail is that it (at least currently) doesn't warn
 * about unreachable code, because the dead code is in the same line as
 * the valid code being kept every pass.
 */
void t13() {
    auto i = 0, j = 1, k = 2;
    if (i && j && k)				print("13ops\n");
    if (i || j || k) /*nothing*/; else		print("13ops\n");
    if (!(i && j && k))/*nothing*/;else		print("13ops\n");
    if (!(i || j || k))				print("13ops\n");
    i ? print("13ops\n") : j ? true : print("13ops\n");
    !j ? print("13ops\n") : i ? print("13ops\n") : k ? true : print("13ops\n");
    (((j))) ? true : print("13ops\n");
    ;;;
    if ((j %= k) != 1)				print("13ops\n");
    if ((i /= j) != 0)				print("13ops\n");
    if (!i != j)				print("13ops\n");
    if (!(i == j))/*nothing*/;else		print("13ops\n");
    if (j < i)					print("13ops\n");
    if (j <= i) 				print("13ops\n");
    if (j == i) 				print("13ops\n");
    if (j >= k) 				print("13ops\n");
    if (j > k)					print("13ops\n");
    if (k >>> 1 != j)				print("13ops\n");
    if (j >>> 1 != i)				print("13ops\n");
    if ((1 << j) != k)				print("13ops\n");
    if (~i != -j)				print("13ops\n");
}
t13();

/* test14 - loop */
auto t14_i = 0, t14_j = 0;
do {
    ++t14_i;
} while (t14_i < 100);
if (t14_i != 100)				print("14ops\n");
do {
    if (--t14_i == 50)
	break;
} while (t14_i > 0);
if (t14_i != 50)				print("14ops\n");
do {
    /* first iteration is false because (t14_i == 50) */
    if (t14_i < 50)
	continue;
    --t14_j;
} while (--t14_i > 0);
if (t14_i != 0)					print("14ops\n");
if (t14_j != t14_i - 1)				print("14ops\n");
for (t14_i = t14_j = 0; t14_i < 100; ++t14_i) {
    if (t14_i & 1)
	continue;
    ++t14_j;
}
if (t14_i != 100 || t14_j != 50)		print("14ops\n");
t14_i = t14_j = 0;
while (true) {
    if ((t14_i += 3) & 1)
	continue;
    t14_j += 3;
    if (t14_i >= 30)
	break;
}
/* not really loops */
if (t14_i != 30 || t14_j != 15)			print("14ops\n");
t14_i = 0, t14_j = 1;
t14_i ^ t14_j ||				print("14ops\n");
t14_i & t14_j &&				print("14ops\n");
!((t14_i | t14_j) == 1) &&			print("14ops\n");
/* XXX this can be optimized or at least generate warnings later */
t14_i = 3, 4, 5;
if (t14_i != 3)					print("14ops\n");
/* the most well known C syntax */
t14_j = (3, 4, 5);
if (t14_j != 5)					print("14ops\n");
if ("012345"[3] != '3')				print("14ops\n");

/* test15 - vector */
auto t15_m[][][] = {
    {
	{1, 2},
	{3, 4}
    },
    {
	{4, 5},
	{6, 7},
    }
};
auto t15_i, t15_j, t15_k;
for (t15_i = 0; t15_i < 2; ++t15_i)
    for (t15_j = 0; t15_j < 2; t15_j++)
	for (t15_k = 0; t15_k < 2; t15_k++)
	    print(" %d", t15_m[t15_i][t15_j][t15_k]);
print("\n");
void
t15() {
    auto m[][][] = {
	{
	    {1, 2},
	    {3, 4}
	},
	{
	    {4, 5},
	    {6, 7},
	}
    };
    auto i, j, k;
    for (i = 0; i < 2; ++i)
	for (j = 0; j < 2; j++)
	    for (k = 0; k < 2; k++)
		print(" %d", m[i][j][k]);
    print("\n");
}
t15();
int8_t t15_i8[][][] = {
    {
	{1, 2},
	{3, 4}
    },
    {
	{4, 5},
	{6, 7},
    }
};
for (t15_i = 0; t15_i < 2; ++t15_i)
    for (t15_j = 0; t15_j < 2; t15_j++)
	for (t15_k = 0; t15_k < 2; t15_k++)
	    print(" %d", t15_i8[t15_i][t15_j][t15_k]);
print("\n");
void
t15_2()
{
    int16_t i16[][][] = {
	{
	    {1, 2},
	    {3, 4}
	},
	{
	    {4, 5},
	    {6, 7},
	}
    };
    auto i, j, k;
    for (i = 0; i < 2; ++i)
	for (j = 0; j < 2; j++)
	    for (k = 0; k < 2; k++)
		print(" %d", i16[i][j][k]);
    print("\n");
}
t15_2();
typedef auto t15_p[];
typedef t15_p t15_pp[];
typedef t15_pp t15_ppp[];
auto t15_x = 10;
t15_ppp t15_v = {
    {
	{t15_x * 1, 2},
	{3, t15_x * 4}
    },
    {
	{4, t15_x * 5},
	{6 * t15_x, 7},
    }
};
for (t15_i = 0; t15_i < 2; ++t15_i)
    for (t15_j = 0; t15_j < 2; t15_j++)
	for (t15_k = 0; t15_k < 2; t15_k++)
	    print(" %d", t15_v[t15_i][t15_j][t15_k]);
print("\n");

/* test16 - reference */
auto *t16_p;
auto t16_n = 10;
t16_p = &t16_n;
print("%d %d\n", t16_n, *t16_p);
*t16_p = 1;
print("%d %d\n", t16_n, *t16_p);
auto t16_v[4] = { 0, 1, 2, 3 };
t16_p = &t16_v[1];
print("%d %d\n", t16_v[1], *t16_p);
*t16_p = 10;
print("%d %d\n", t16_v[1], *t16_p);
int8_t t16_vi8[4] = { 0, 1, 2, 3 };
t16_p = &t16_vi8[1];
print("%d %d %d\n", t16_vi8[1], t16_vi8[2], *t16_p);
*t16_p = 10;
print("%d %d %d\n", t16_vi8[1], t16_vi8[2], *t16_p);
int16_t *t16_pi16;
int16_t t16_vi16[4] = { 0, 1, 2, 3 };
t16_pi16 = &t16_vi16[1];
print("%d %d %d\n", t16_vi16[1], t16_vi16[2], *t16_pi16);
*t16_pi16 = 10;
print("%d %d %d\n", t16_vi16[1], t16_vi16[2], *t16_pi16);
struct t16_test {
    auto pad;
    int8_t i8;
    float32_t f32;
    auto any;
};
t16_test t16_t = { null, 'a', 3/7.0, "a long string" };
t16_p = &t16_t.i8;
print("%c %c\n", t16_t.i8, *t16_p);
*t16_p -= 'a' - 'A';
print("%c %c\n", t16_t.i8, *t16_p);

/* test17 - reference */
auto t17_of(a, b, c);			// prototype
// (nil (t17_of a b c))
auto *t17_ft(a, b, c);			// prototype
// (nil (pointer (t17_ft a b c)))
auto *(t17_pof)(a, b, c);		// prototype (returns auto *)
// (nil (pointer (t17_pof a b c)))	-- parenthesis are not required
auto (*t17_fp)(...) = &print;		// type
// (nil (set ((pointer t17_fp) (...)) (address print)))
(*t17_fp)("%d\n", 1);
typedef auto (*t17_f)(...);
// (typedef nil ((pointer t17_f) (...)))
auto *(t17_pof2)(a, b, c)
{
    print("%d %d %d\n", a, b, c);
    return null;
}
// (nil ((pointer (t17_pof2 a b c)) (code (progn (print "%d %d %d\012" a b c)) (return nil))))
typedef auto *(*t17_pf)(...);		// return type is an 'auto *'
// (typedef nil (pointer ((pointer t17_pf) (...))))

/* test18 - typedef & type specifiers & redeclaration (without definition) */
/*   The beauty of the expressiveness of C, and declaration of complex
 * data types.
 *   The language should have very few usages of pointers directly,
 * as objects are already pointers (or better said, references)
 */
typedef auto T;			// (typedef auto T)
typedef auto T;			// (typedef #<T> #<T>)
T t;				// (T t)
T t;				// (T t)
typedef T t_t;			// (typedef T t_t)
typedef T t_t;			// (typedef #<t_t> #<t_t>)
T *pt;				// (T (* pt))
T *pt;				// (T (* pt))
typedef T *pt_t;		// (typedef T (* pt_t))
typedef T *pt_t;		// (typedef T (* #<pt_t>))
auto **ppt;			// (T (* (* ppt)))
auto **ppt;			// (T (* (* ppt)))
typedef T **ppt_t;		// (typedef T (* (* ppt_t)))
typedef T **ppt_t;		// (typedef T (* (* #<ppt_t>)))
T (*t_pf)(a);			// (T ((* t_pf) a))
T (*t_pf)(a);			// (T ((* t_pf) a))
typedef T (*t_pf_t)(a);		// (typedef T ((* t_pf_t) a))
typedef T (*t_pf_t)(a);		// (typedef T ((* #<t_pf_t>) a))
T (**t_ppf)(a);			// (T ((* (* t_ppf)) a))
T (**t_ppf)(a);			// (T ((* (* t_ppf)) a))
typedef T (**t_ppf_t)(a);	// (typedef T ((* (* t_ppf_t)) a))
typedef T (**t_ppf_t)(a);	// (typedef T ((* (* #<t_ppf_t>)) a))
T *(pt_f)(a);			// (T (* (pt_f a)))
T *(pt_f)(a);			// (T (* (pt_f a)))
//--
// error: needs '*', otherwise is just a prototype
// typedef T *(pt_f_t)(a);	// (typedef T (* (pt_f_t a)))
//--
T **ppt_f(a);			// (T (* (* (ppt_f a))))
T **ppt_f(a);			// (T (* (* (ppt_f a))))
//--
// error: needs '*', otherwise is just a prototype
// typedef T **(ppt_f_t)(a);	// (typedef T (* (* (ppt_f_t a))))
//--
T *(*pt_pf)(a);			// (T (* ((* pt_pf) a)))
T *(*pt_pf)(a);			// (T (* ((* pt_pf) a)))
typedef T *(*pt_pf_t)(a);	// (T (* ((* pt_pf_t) a)))
typedef T *(*pt_pf_t)(a);	// (T (* ((* #<pt_pf_t>) a)))
T **(*ppt_pf)(a);		// (T (* (* ((* ppt_pf) a))))
T **(*ppt_pf)(a);		// (T (* (* ((* ppt_pf) a))))
typedef T **(*ppt_pf_t)(a);	// (typedef T (* (* ((* ppt_pf_t) a))))
typedef T **(*ppt_pf_t)(a);	// (typedef T (* (* ((* #<ppt_pf_t>) a))))
T *(**pt_ppf)(a);		// (T (* ((* (* pt_ppf)) a)))
typedef T *(**pt_ppf_t)(a);	// (T (* ((* (* pt_ppf_t)) a)))
typedef T *(**pt_ppf_t)(a);	// (T (* ((* (* #<pt_ppf_t>)) a)))
T **(**ppt_ppf)(a);		// (T (* (* ((* (* ppt_ppf)) a))))
T **(**ppt_ppf)(a);		// (T (* (* ((* (* ppt_ppf)) a))))
typedef T **(**ppt_ppf_t)(a);	// (typedef T (* (* ((* (* ppt_ppf)) a))))
typedef T **(**ppt_ppf_t)(a);	// (typedef T (* (* ((* (* #<ppt_ppf>)) a))))
T vt[];				// (T [ vt nil])
T vt[];				// (T [ vt nil])
typedef T vt_t[];		// (typedef T [ vt_t nil])
typedef T vt_t[];		// (typedef T [ #<vt_t> nil])
T (*pvt)[];			// (T [ (* pvt) nil])
T (*pvt)[];			// (T [ (* pvt) nil])
typedef T (*pvt_t)[];		// (typedef T [ (* pvt_t) nil])
typedef T (*pvt_t)[];		// (typedef T [ (* #<pvt_t>) nil])
// vector of function pointers that returns a pointer
T *(*pt_fv)[](a);		// (T (* ([ (* pt_pfv) nil] a)))
T *(*pt_fv)[](a);		// (T (* ([ (* pt_pfv) nil] a)))
typedef T *(*pt_pfv_t)[](a);	// (typedef T (* ([ (* pt_pfv_t) nil] a)))
typedef T *(*pt_pfv_t)[](a);	// (typedef T (* ([ (* #<pt_pfv_t>) nil] a)))
// function that returns a vector
/*
 * error: this is an impossible type.
 * it is syntactically correct, but cannot be instantiated,
 * instead, must use a vector of function pointers.
T v_f(a)[];			// (T [ (v_f a) nil])
T v_f(a)[];			// (T [ (v_f a) nil])
 */
//--
// error: needs '*', otherwise is just a prototype
// typedef T v_f_t(a)[];	// (typedef T [ (v_f_t a) nil])
//--
T (*v_pf)(a)[];			// (T [ ((* v_pf) a) nil])
T (*v_pf)(a)[];			// (T [ ((* v_pf) a) nil])
typedef T (*v_pf_t)(a)[];	// (T [ ((* v_pf) a) nil])
typedef T (*v_pf_t)(a)[];	// (T [ ((* #<v_pf>) a) nil])
// function pointer that returns a vector
T (*v_pf)(a)[];			// (T [ (v_pf a) nil])
T (*v_pf)(a)[];			// (T [ (v_pf a) nil])
typedef T (*v_pf_t)(a)[];	// (typedef T [ ((* v_pf_t) a) nil])
typedef T (*v_pf_t)(a)[];	// (typedef T [ ((* #<v_pf_t>) a) nil])
// vector of functions that returns T
/*
 * error: this is an impossible type.
 * it is syntactically correct, but cannot be instantiated,
 * instead, must use a vector of function pointers.
T t_fv[](a);			// (T ([ t_fv nil] a))
T t_fv[](a);			// (T ([ t_fv nil] a))
 */
//--
// error: needs '*', otherwise is just a declaration
// typedef T t_fv_t[](a);	// (typedef T ([ t_fv_t nil] a))
//--
T (*t_pfv)[](a);		// (T ([ (* t_pfv) nil] a))
T (*t_pfv)[](a);		// (T ([ (* t_pfv) nil] a))
typedef T (*t_pfv_t)[](a);	// (typedef T ([ (* t_pfv_t) nil] a))
typedef T (*t_pfv_t)[](a);	// (typedef T ([ (* #<t_pfv_t>) nil] a))
// vector of functions that return a vector
/*
 * error: this is an impossible type.
 * it is syntactically correct, but cannot be instantiated,
 * instead, must use a vector of function pointers.
T v_vf[](a)[];			// (T [ ([ v_vf nil] a) ])
T v_vf[](a)[];			// (T [ ([ v_vf nil] a) ])
 */
// error: needs '*', otherwise is just a declaration
// typedef T v_vf_t[](a)[];	// (typedef T [ ([ v_f_t nil] a) ])
//--
T (*v_vpf)[](a)[];		// (T [ ([ (* v_vpf) nil] a) ])
T (*v_vpf)[](a)[];		// (T [ ([ (* v_vpf) nil] a) ])
typedef T (*v_vpf_t)[](a)[];	// (typedef T [ ([ (* v_vpf_t) nil] a) ])
typedef T (*v_vpf_t)[](a)[];	// (typedef T [ ([ (* #<v_vpf_t>) nil] a) ])

/* test19 - http://www.lysator.liu.se/c/duffs-device.html */
/* pointer arithmetic not implemented */
/* there are variants that also use break */
void
t19_duffy(to[], from[], count)
{
    auto i, j;
    auto n = (count + 7) \ 8;
    i = j = 0;
    switch (count % 8) {
	case 0:	do {	to[i++] = from[j++];
	case 7:		to[i++] = from[j++];
	case 6:		to[i++] = from[j++];
	case 5:		to[i++] = from[j++];
	case 4:		to[i++] = from[j++];
	case 3:		to[i++] = from[j++];
	case 2:		to[i++] = from[j++];
	case 1:		to[i++] = from[j++];
		} while (--n > 0);
    }
}
auto t19_to[] = { 0, 0, 0, 0, 0 };
auto t19_from[] = { 1, 2, 3, 4, 5 };
t19_duffy(t19_to, t19_from, 5);
print("%d %d %d %d %d\n",
      t19_to[0], t19_to[1], t19_to[2], t19_to[3], t19_to[4]);

/* test20 - union & declaration */
union t20_basic {
    auto o, *p, v[], (*f)(string, ...);
};
t20_basic t20_b;
t20_b.o = "foobar";
print("%s\n", t20_b.o);
t20_b.v = { 1, 2, 3 };
print("%d %d %d\n", t20_b.v[0], t20_b.v[1], t20_b.v[2]);
t20_b.p = &new auto;
*t20_b.p = 1.2;
print("%f\n", *(t20_b.p));
t20_b.f = &print;
(*t20_b.f)("ok\n");
union t20_a_t {
    auto vo[];
    int32_t vi[];
};
union t20_b_t {
    t20_a_t a;
    float64_t vd[];
};
t20_b_t t20_v;
t20_v.a.vo = { 1, 2, 3 };
print("%d %d %d\n", t20_v.a.vo[0], t20_v.a.vo[1], t20_v.a.vo[2]);
t20_v.vd = { 1.23, 4.56, 7.89 };
print("%f %f %f\n", t20_v.vd[0], t20_v.vd[1], t20_v.vd[2]);
struct t20_s_t {
    int8_t	s8;
    int32_t	s32;
} t20_sa, t20_sb;
t20_sa = new t20_s_t;		// requiring initializing can be misleading
t20_sb = new t20_s_t;		// when used to C, because objects are pointers,
/* FIXME maybe could do implicit initialization to a "default" initializer
 * if the object fields/elements are accessed, but this most likely would
 * require some "weird" code when it is not clear if the object is initialized,
 * like a run time check */
t20_sa.s8 = t20_sb.s32 = 253;	// not stack/heap objects
print("%d %d\n", t20_sa.s8, t20_sb.s32);
union t20_check {
    int8_t	s8;		// should ignore modifiers (for now at least)
    int32_t	s32;		// same
} t20_ua, t20_ub;
t20_ua.s8 = t20_ub.s32 = 250;
print("%d %d\n", t20_ua.s8, t20_ub.s32);
/* useful if one wants to keep a "type/kind tag" on declarations,
 * that is, treat struct/union declarations as the C statement:
 *	typedef struct <name> <name>;
 */
struct t20_s_t t20_saa, t20_sbb;
union t20_check t20_uaa, t20_ubb;
struct t20_ss_t {
    float32_t	f;
    int32_t	i;
} t20_ssa = {
    1.0, 3
}, t20_ssb = {
    2.0, 6
};
print("%f, %d - %f, %d\n", t20_ssa.f, t20_ssa.i, t20_ssb.f, t20_ssb.i);
struct t20_with_union;
union t20_with_struct {
    union t20_check c;
    struct t20_with_union s;
};
struct t20_with_union {
    union t20_with_struct u;
    int32_t i;
    auto v[];
} t20_wu;
t20_wu = new t20_with_union;
t20_wu.u.c.s32 = 1;
t20_wu.v = { 2, 3 };
print("%d %d %d\n", t20_wu.u.c.s32, t20_wu.v[0], t20_wu.v[1]);
t20_v.a.vo = { 3, 2, 1 };
print("%d %d %d\n", t20_v.a.vo[0], t20_v.a.vo[1], t20_v.a.vo[2]);
/* make a circular object and check fields dereference by "circulating" it */
t20_wu.u.s = t20_wu;
t20_wu.u.s.u.s.v = { "one", "two" };
print("%s %s\n", t20_wu.u.s.u.s.v[0], t20_wu.u.s.u.s.v[1]);
t20_wu.u.s.u.s.i = 42;
print("%d\n", t20_wu.u.s.u.s.i);

/* test21 - some adaptation of gcc testsuite */
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/compat/strct-layout.c
 **********************************************************************/
struct t21_1_t {
    int8_t a;
    int32_t b;
    int8_t c;
    int16_t d;
    float64_t e;
    int8_t f;
};
void t21_1_f(t21_1_t x[])
{
    x[0].a = 'a';
    x[0].b = 47114711;
    x[0].c = 'c';
    x[0].d = 1234;
    x[0].e = 3.141592897932;
    x[0].f = '*';
    x[1].a = 'A';
    x[1].b = 71417141;
    x[1].c = 'C';
    x[1].d = 4321;
    x[1].e = 2.718281828459;
    x[1].f = '?';
}
void t21_1_g(t21_1_t x[])
{
    if (x[0].a != 'a')			print("error %d\n", __LINE__);
    if (x[0].b != 47114711)		print("error %d\n", __LINE__);
    if (x[0].c != 'c')			print("error %d\n", __LINE__);
    if (x[0].d != 1234)			print("error %d\n", __LINE__);
    if (x[0].e != 3.141592897932)	print("error %d\n", __LINE__);
    if (x[0].f != '*')			print("error %d\n", __LINE__);
    if (x[1].a != 'A')			print("error %d\n", __LINE__);
    if (x[1].b != 71417141)		print("error %d\n", __LINE__);
    if (x[1].c != 'C')			print("error %d\n", __LINE__);
    if (x[1].d != 4321)			print("error %d\n", __LINE__);
    if (x[1].e != 2.718281828459)	print("error %d\n", __LINE__);
    if (x[1].f != '?')			print("error %d\n", __LINE__);
}
/* first check static initializer */
t21_1_t t21_1_x[2] = {
    { 'a', 47114711, 'c', 1234, 3.141592897932, '*' },
    { 'A', 71417141, 'C', 4321, 2.718281828459, '?' }
};
t21_1_g(t21_1_x);
/* now dynamic initializer (that initializes to the same values) */
t21_1_f(t21_1_x);
t21_1_g(t21_1_x);
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/compat/struct-align.c
 **********************************************************************/
struct t21_2_s_t {
    int32_t a;
    int32_t b;
};
union t21_2_t {
    t21_2_s_t s;
    float64_t d;
};
void t21_2_h(t21_2_t *x);
t21_2_t t21_2_g(t21_2_t);
void t21_2_h(t21_2_t *x)
{
    if ((*x).s.a != 0 || (*x).s.b != 1)	print("error %d\n", __LINE__);
}
t21_2_t t21_2_g(t21_2_t x)
{
    if (x.s.a != 13 || x.s.b != 47)	print("error %d\n", __LINE__);
    /* unlike the gcc test case, objects are always references,
     * reallocate x.s to simulate using it by value (this is using
     * the language union semantics, where it works as cast,
     * and fields are never dereferenced, because they do not actually
     * exist) */
    x.s = new t21_2_s_t;
    x.s.a = 0;
    x.s.b = 1;
    t21_2_h(&x);
    return x;
}
void t21_2_f(void)
{
    t21_2_t x;
    x.s = new t21_2_s_t;
    x.s.a = 13;
    x.s.b = 47;
    t21_2_g(x);
    if (x.s.a != 13 || x.s.b != 47)	print("error %d\n", __LINE__);
    x = t21_2_g(x);
    if (x.s.a != 0 || x.s.b != 1)	print("error %d\n", __LINE__);
}
t21_2_f();
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/compat/struct-big.c
 **********************************************************************/
struct t21_3_t { int32_t a, b, c, d, e; };
void t21_3_h(t21_3_t);
t21_3_t t21_3_g(t21_3_t);
void t21_3_h(t21_3_t x)
{
    if (x.a != 0 || x.b != 1 || x.c != 2 || x.d != 3 || x.e != 4)
	print("error %d\n", __LINE__);
}
t21_3_t t21_3_g(t21_3_t x)
{
    if (x.a != 13 || x.b != 47 || x.c != 123456 || x.d != -4711 || x.e != -2)
	print("error %d\n", __LINE__);
    /* unlike the gcc test case, objects are always references,
     * reallocate local variable to simulate using x by value */
    x = new t21_3_t;
    x.a = 0;
    x.b = 1;
    x.c = 2;
    x.d = 3;
    x.e = 4;
    t21_3_h(x);
    return x;
}
void t21_3_f()
{
    struct t21_3_t x = new t21_3_t;
    x.a = 13;
    x.b = 47;
    x.c = 123456;
    x.d = -4711;
    x.e = -2;
    t21_3_g(x);
    if (x.a != 13 || x.b != 47 || x.c != 123456 || x.d != -4711 || x.e != -2)
	print("error %d\n", __LINE__);
    x = t21_3_g(x);
    if (x.a != 0 || x.b != 1 || x.c != 2 || x.d != 3 || x.e != 4)
	print("error %d\n", __LINE__);
}
t21_3_f();
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/compat/struct-i.c
 **********************************************************************/
struct t21_4_t { int32_t a; };
void t21_4_h(t21_4_t);
t21_4_t t21_4_g(t21_4_t);
void t21_4_h(t21_4_t x)
{
    if (x.a != 47114711)		print("error %d\n", __LINE__);
}
t21_4_t t21_4_g(t21_4_t x)
{
    if (x.a != 13)			print("error %d\n", __LINE__);
    /* fun stuff, right side knowns left side type */
    x = { 47114711 };
    t21_4_h(x);
    return x;
}
void t21_4_f()
{
    t21_4_t x = new t21_4_t;
    x.a = 13;
    t21_4_g(x);
    if (x.a != 13)			print("error %d\n", __LINE__);
    x = t21_4_g(x);
    if (x.a != 47114711)		print("error %d\n", __LINE__);
}
t21_4_f();
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/compat/struct-ret-1.c
 **********************************************************************/
struct t21_5_t { int32_t re; int32_t im; };
t21_5_t t21_5_f(int32_t, int32_t);
t21_5_t t21_5_f(int32_t arg1, int32_t arg2)
{
    t21_5_t x = { arg1, arg2 };
    return x;
}
t21_5_t t21_5_result;
t21_5_result = t21_5_f(3, 4);
if (t21_5_result.re != 3 || t21_5_result.im != 4)
    print("error %d\n", __LINE__);
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/unsorted/bt386.c
 **********************************************************************/
auto t21_6_foo(a, b)
{
    return (a & (1 << b)) != 0;
}
auto t21_6_bar(a, b)
{
    a ^= (1 << b);
    return a != 0;
}
auto t21_6_i;
for (t21_6_i = 0; t21_6_i < 32; t21_6_i++)
    print("%d ", t21_6_foo(0x8000000f, t21_6_i));
print("\n");
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/unsorted/dshift.c
 **********************************************************************/
/* this test gives the same result of changing the gcc test one to use
 * long long as foo() result and arguments; here it just became some
 * random test... */
auto t21_7_foo(b, c)
{
    return (b << 12) | (c >>> 20);
}
print("0x%x\n", t21_7_foo(0x11223344, 0xaabbccdd));
/* but the intended test can be simulated with a struct */
struct t21_7_t { uint32_t ui; };
t21_7_t t21_7_foo1(t21_7_t b, t21_7_t c)
{
    t21_7_t v = { (b.ui << 12) | (c.ui >>> 20) };
    return v;
}
t21_7_t t21_7_b = { 0x11223344 }, t21_7_c = { 0xaabbccdd };
print("0x%x\n", t21_7_foo1(t21_7_b, t21_7_c).ui);
/**********************************************************************
 * gcc/testsuite/gcc.c-torture/unsorted/as.c
 **********************************************************************/
/* same comments as t21_7 ... */
#define t21_8_S	31
#define t21_8_A	17
auto t21_8_foo(a)
{
    return (a >>> t21_8_S) & ((1 << t21_8_A) - 1);
}
print("%d%d\n", t21_8_foo(-1), t21_8_foo(0));
/* and the struct simulation */
struct t21_8_t { uint32_t ui; };
struct t21_8_t t21_8_foo1(struct t21_8_t a)
{
    t21_8_t v = { (a.ui >>> t21_8_S) & ((1 << t21_8_A) - 1) };
    return v;
}
t21_8_t t21_8_b = { -1 }, t21_8_c = { 0 };
print("%d%d\n", t21_8_foo1(t21_8_b).ui, t21_8_foo1(t21_8_c).ui);

/* test22 - labeled initializers */
auto t22_a[3] = {
    2:	20,
    0:	1,
    44
};
if (t22_a[0] != 1 || t22_a[1] != 44 || t22_a[2] != 20)
    print("error %d\n", __LINE__);
struct t22_b_t {
    int32_t	s32;
    uint32_t	u32;
    auto	any;
} t22_b = {
    44,
    any:	22,
    u32:	66,
};
if (t22_b.s32 != 44 || t22_b.u32 != 66 || t22_b.any != 22)
    print("error %d\n", __LINE__);
struct t22_c_t {
    int8_t	s8;
    uint8_t	u8;
    int16_t	s16;
    uint16_t	u16;
    int32_t	s32;
    uint32_t	u32;
    int64_t	s64;
    uint64_t	u64;
    float32_t	f32;
    float64_t	f64;
    auto	any;
} t22_c = {
    any:	true,
    u32:	  32,
    s16:	 -16,
    f64:	  64.0,
    s32:	 -32,
    u8:		   8,
    f32:	  32.0,
    s8:		  -8,
    s64:	 -64,
		  44,
    u16:	  16,
};
if ( t22_c.s8 !=   -8 ||  t22_c.u8 !=    8 ||
    t22_c.s16 !=  -16 || t22_c.u16 !=   16 ||
    t22_c.s32 !=  -32 || t22_c.u32 !=   32 ||
    /* u64 field must initialize to 44, as it follows the s64 field */
    t22_c.s64 !=  -64 || t22_c.u64 !=   44 ||
    t22_c.f32 != 32.0 || t22_c.f64 != 64.0 ||
    t22_c.any != true)			print("error %d\n", __LINE__);
union t22_d_u_t;
struct t22_d_s_t {
    t22_d_u_t	u;
    int32_t	s32;
};
union t22_d_u_t {
    t22_d_s_t	s;
    float32_t	f32;
};
t22_d_s_t t22_d = {
    u: {
	s: {
	    u: {
		f32: 8.4,
	    },
	    s32: 42,
	},
    },
    21,
};
if (t22_d.u.s.u.f32 != 8.4 || t22_d.u.s.s32 != 42 || t22_d.s32 != 21)
    print("error %d\n", __LINE__);
/* check if dynamic initialization also works */
void t22_d_f(void)
{
    t22_d_s_t d = {
	u: {
	    s: {
		u: {
		    f32: 4.2,
		},
		s32: 21,
	    },
	},
	42,
    };
    if (d.u.s.u.f32 != 4.2 || d.u.s.s32 != 21 || d.s32 != 42)
	print("error %d\n", __LINE__);
}
t22_d_f();
union t22_e_u_t;
struct t22_e_s_t {
    union t22_e_u_t u;
    auto o;
};
union t22_e_u_t {
    struct t22_e_s_t s;
    auto o;
};
t22_e_s_t t22_e = {
    u: {
	s: {
	    u: {
		o: 8.4,
	    },
	    o: 42,
	},
    },
    21,
};
if (t22_e.u.s.u.o != 8.4 || t22_e.u.s.o != 42 || t22_e.o != 21)
    print("error %d\n", __LINE__);
/* check if dynamic initialization also works */
void t22_e_f(void)
{
    t22_e_s_t e = {
	u: {
	    s: {
		u: {
		    o: 4.2 + t22_e.u.s.u.o,
		},
		o: 21,
	    },
	},
	42,
    };
    if (e.u.s.u.o != 4.2 + t22_e.u.s.u.o || e.u.s.o != 21 || e.o != 42)
	print("error %d\n", __LINE__);
}
t22_e_f();

/* test23 - typeof */
int8_t t23_v[1] = { 'a' };
if (typeof (int8_t[]) != typeof (t23_v))
    print("error %d\n", __LINE__);
if (typeof t23_v[0] != typeof 'a')
    print("error %d\n", __LINE__);
int8_t *t23_p = &t23_v[0];
if (typeof (t23_p) != typeof int8_t*)
    print("error %d\n", __LINE__);
float32_t t23_vv[2][2] = { { 1, 2 }, { 3, 4 }};
float32_t *t23_pp = &t23_vv[0][0];
if (typeof t23_vv[0][0] != typeof *t23_pp)
    print("error %d\n", __LINE__);
auto t23_vo[2][] = {{ 1, 2 }, { 3, 4 }};
auto *t23_vop = &t23_vo[1];
if (typeof (t23_vo[1]) != typeof (*t23_vop))
    print("error %d\n", __LINE__);
struct t23_s_t { int32_t i; auto o; } t23_s = { 1, "foobar" };
if (typeof t23_s.i != typeof 1 || typeof(t23_s.i) != typeof(int32_t) ||
    typeof(t23_s.o) != typeof("") || typeof t23_s.o != typeof(uint8_t[]))
    print("error %d\n", __LINE__);
union t23_u_t { t23_s_t s; int32_t i; } t23_u = { s: { 2, "blah" } };
if (typeof t23_u.s.i != typeof int32_t || typeof "123" != typeof t23_u.s.o ||
    typeof t23_u != typeof t23_s_t || typeof t23_u != typeof t23_s)
    print("error %d\n", __LINE__);
t23_u = 4.5;
if (typeof t23_u != typeof 3.2)
    print("error %d\n", __LINE__);
switch (typeof 3) {
    case int64_t:
	break;
    default:
	print("error %d\n", __LINE__);
	break;
}
switch (typeof(3.4)) {
    case float64_t:
	break;
    default:
	print("error %d\n", __LINE__);
	break;
}
switch (typeof "abc") {
    case typeof(uint8_t[]):
	break;
    default:
	print("error %d\n", __LINE__);
	break;
}
switch (typeof "cde") {
    case uint8_t[]:
	break;
    default:
	print("error %d\n", __LINE__);
	break;
}
string_t t23_str = "def";
pointer_t t23_ptr = &t23_str[1];
switch (typeof t23_ptr) {
    case uint8_t*:
	break;
    default:
	print("error %d\n", __LINE__);
	break;
}
string_t *t23_str1 = &"abc";
if (typeof t23_str1 != typeof &"abc")
    print("error %d\n", __LINE__);
if (typeof((*t23_str1)[1]) != typeof "abc"[1])
    print("error %d\n", __LINE__);
function_t t23_fp = &print;
if (typeof t23_fp != typeof &print)
    print("error %d\n", __LINE__);
auto t23_obj;
if (typeof t23_obj != typeof null)
    print("error %d\n", __LINE__);
t23_obj = false;
if (typeof t23_obj != typeof false)
    print("error %d\n", __LINE__);

/* test24 - sizeof */
/* this is a very simple sizeof, that doesn't really match C,
 * but instead serves only to get a vector length, what doesn't
 * either match C semantics; only the identifier is borrowed
 * from C, (FIXME at least for now) */
string_t t24_1 = "1234567890";
if (sizeof t24_1 != 10)			print("error %d\n", __LINE__);
int32_t t24_2[] = new(int32_t[16]);
auto t24_2_i;
if (sizeof(t24_2) != 16)		print("error %d\n", __LINE__);
for (t24_2_i = 0; t24_2_i < sizeof(t24_2); ++t24_2_i)
    t24_2[t24_2_i] = t24_2_i * 2;
for (t24_2_i = 0; t24_2_i < sizeof(t24_2); ++t24_2_i)
    if (t24_2[t24_2_i] != t24_2_i * 2)	print("error %d\n", __LINE__);
float64_t t24_3[] = new float64_t[4][4];
if (sizeof(t24_3) != 16)		print("error %d\n", __LINE__);

/* test25 - varargs */
auto t25_n;
auto t25_f1(...)
{
    auto i, n = sizeof(...);
    for (i = 0; i < n; i++) {
	...[i] = i * 10;
	if (...[i] != i * 10)		print("error %d\n", __LINE__);
    }
    return n;
}
if ((t25_n = t25_f1(1, 2, 3)) != 3)	print("error %d\n", __LINE__);
if ((t25_n = t25_f1()) != 0)		print("error %d\n", __LINE__);
auto t25_f2(a, b, ...)
{
    auto i, n = sizeof(...);
    print("%d %d ", a, b);
    for (i = 0; i < n; i++)
	print("%d ", ...[i]);
    print("\n");
    return n + 2;
}
if ((t25_n = t25_f2(1, 2, 3)) != 3)	print("error %d\n", __LINE__);
if ((t25_n = t25_f2(1, 2)) != 2)	print("error %d\n", __LINE__);
if ((t25_n = t25_f2(1, 2, 3, 4, 5, 6, 7, 8, 9)) != 9)
    print("error %d\n", __LINE__);
auto t25_f3(a, ...)
{
    auto i, n = sizeof(...);
    print("[0]=%d\n", a);
    for (i = 0; i < n; ++i) {
	auto *p = &...[i];
	print("[%d]=%d %d\n", i + 1, ...[i], *p);
	*p = i + 2;
	print("(%d %d)\n", ...[i], *p);
    }
    return n + 1;
}
if ((t25_n = t25_f3(3, -1, -2)) != 3)	print("error %d\n", __LINE__);
auto t25_f4(a, ...)
{
    auto i, n = sizeof(...);
    if (n != 2)				print("error %d\n", __LINE__);
    print("[0]=%d - %d\n", a, a - 2);
    auto *p = &...[0];
    print("[1]=%d %d\n", ...[0], *p);
    *p -= 2;
    print("(%d %d)\n", ...[0], *p);
    p = &...[1];
    print("[2]=%d %d\n", ...[1], *p);
    *p -= 2;
    print("(%d %d)\n", ...[1], *p);
    return n + 1;
}
if ((t25_n = t25_f4(5, 4, 3)) != 3)	print("error %d\n", __LINE__);

/* test26 - "very" basic inheritance */
struct t26_rect {
    int32_t	x, y;
    uint32_t	w, h;
};
struct t26_label : t26_rect {
    string_t	text;
};
struct t26_button : t26_label {
    function_t	press;
};
void t26_press_callback(t26_button b)
{
    print("pressed button '%s', at %d,%d with size %d,%d\n",
	  b.text, b.x, b.y, b.w, b.h);
}
t26_button t26_b = {
    x: 10, y: 5, w: 80, h: 20, text: "OK", press: &t26_press_callback
};
(*t26_b.press)(t26_b);
//--
struct t26_pos { int32_t x, y; };
struct t26_position : t26_pos;
t26_position t26_m = { 5, 5 };
if (t26_m.x != 5 || t26_m.y != 5)	print("error %d\n", __LINE__);
union t26_si { int8_t i8; int16_t i16; };
union t26_fixed_integer : t26_si { int32_t i32; int64_t i64; };
t26_fixed_integer t26_fi = { i16: 10 };

/* test 27 - test usage of pointers in loops */
auto t27_i;
/* struct field pointer to auto global */
struct t27_p_t { auto notused; pointer_t p; } t27_p = {};
for (t27_p.p = &t27_i, t27_i = 0; *t27_p.p < 10; ++*t27_p.p)
    if (*t27_p.p != t27_i)
	print("error %d: %d %d\n", __LINE__, *t27_p.p, t27_i);
/* struct field pointer to struct field auto */
struct t27_pi_t { auto notused; pointer_t p; auto i; } t27_pi = { 0, null, 0 };
for (t27_pi.p = &t27_pi.i, t27_pi.i = 0; *t27_pi.p < 10; ++*t27_pi.p)
    if (*t27_pi.p != t27_pi.i)
	print("error %d: %d %d\n", __LINE__, *t27_pi.p, t27_pi.i);
/* struct field pointer to struct field int8 */
struct t27_pc_t { auto notused; pointer_t p; int8_t c; } t27_pc = { 0, null, 0 };
for (t27_pc.p = &t27_pc.c, t27_pc.c = 0; *t27_pc.p < 10; ++*t27_pc.p)
    if (*t27_pc.p != t27_pc.c)
	print("error %d: %d %d\n", __LINE__, *t27_pc.p, t27_pc.c);
/* vector pointer to auto global */
pointer_t t27_vp[1] = {};
for (t27_vp[0] = &t27_i, t27_i = 0; *t27_vp[0] < 10; ++*t27_vp[0])
    if (*t27_vp[0] != t27_i)
	print("error %d: %d %d\n", __LINE__, *t27_vp[0], t27_i);
/* vector pointer to struct field int8 */
for (t27_vp[0] = &t27_pc.c, t27_pc.c = 0; *t27_vp[0] < 10; ++*t27_vp[0])
    if (*t27_vp[0] != t27_pc.c)
	print("error %d: %d %d\n", __LINE__, *t27_vp[0], t27_pc.c);

/* test 28 - very basic class methods test */
class t28_alive {
    string_t name;
    string_t isa() { return "alive"; }
    /* only method prototype */
    void rename(string_t name);
    void speak() { print("Hi! My name is %s, and I am a %s.\n", name, isa()); }
    void show() { print("alive"); }
};
/* method definition outside class definition block */
void t28_alive.rename(string_t name) { this.name = name; }
class t28_animal : t28_alive {
    string_t isa() { return "animal"; }
    void show() { t28_alive.show(); print(" -> animal"); }
};
class t28_spider : t28_animal {
    string_t isa() { return "spider"; }
    void show() { t28_animal.show(); print(" -> spider"); }
};
class t28_reptile : t28_animal {
    string_t isa() { return "reptile"; }
    void show() { t28_animal.show(); print(" -> reptile"); }
};
class t28_snake : t28_reptile {
    string_t isa() { return "snake"; }
    void show() { t28_reptile.show(); print(" -> snake"); }
};
class t28_mammal : t28_animal {
    string_t isa() { return "mammal"; }
    void show() { t28_animal.show(); print(" -> mammal"); }
};
class t28_feline : t28_mammal {
    string_t isa() { return "feline"; }
    /* method prototype with redundant information */
    string_t t28_feline.meow();
    /* method definition with redundant information */
    string_t t28_feline.meow() { return "Roar"; }
    void show() { t28_mammal.show(); print(" -> feline"); }
};
class t28_cat : t28_feline {
    string_t isa() { return "cat"; }
    void speak() { print("%s! Me %s, Iza %s.\n", meow(), this.name, this.isa()); }
    /* prototype of overriden virtual method */
    string_t meow();
    /* virtual method definition */
    string_t meow() { return "Meow"; }
    void show() { t28_feline.show(); print(" -> cat"); }
};
t28_alive t28_a = new t28_cat { name: "George" };
/* slower runtime field access due to
 * runtime type or t28_a not matching compile time declared type,
 * ofcourse, this could be optimized to modify the type, as it is
 * being assigned a type value computed, but ignored, at compile time */
print("%s the %s.\n", t28_a.name, t28_a.isa());
t28_a = new t28_feline { name: "Felix" };
/* also slower runtime field access due to unmatching type */
t28_feline t28_b = t28_a;	/* method meow() cannot be called from t28_a
				 * because its declared type doesn't have
				 * the method */
print("%s the %s. %s.\n", t28_a.name, t28_a.isa(), t28_b.meow());
print("A %s with %s.\n", (new t28_snake).isa(),
      (new t28_spider { name: "Gloria"}).name);
/* faster runtime field access, as t28_a
 * is now initialized to a value that matches its declared type */
t28_a = { name: "Something" };
print("%s is %s.\n", t28_a.name, t28_a.isa());
t28_a = new t28_reptile { name: "Robert" };
t28_a.speak();
t28_a = new t28_cat { name: "Jesse" };
t28_a.speak();
t28_a = new t28_mammal { name: "Barney" };
t28_a.speak();
new (t28_animal { name: "Alfred" }).speak();
t28_a.rename("Fred");
t28_a.speak();
new(t28_cat).show(); print("\n");
new(t28_snake).show(); print("\n");
new(t28_spider).show(); print("\n");
// override virtual method resolution from code outside a class method
new(t28_cat).t28_animal.show(); print("\n");

/* test 29 - ++ and -- tests with non symbol arguments */
union t29_u {
    auto	o, *p;
} t29_au;
t29_au.o = 1;
++t29_au.o;
t29_au.o--;
if (t29_au.o != 1)			print("error %d\n", __LINE__);
struct t29_s {
    auto	o, *p;
} t29_as = new t29_s;
t29_as.o = 1/2;
t29_as.o++;
--t29_as.o;
if (t29_as.o != 1/2)			print("error %d\n", __LINE__);
auto t29_ao[] = { -1.0L };
++t29_ao[0];
t29_ao[0]--;
if (t29_ao[0] != -1.0L)			print("error %d\n", __LINE__);
t29_au.p = &t29_as.o;
*t29_au.p++;
--*t29_au.p;
if (t29_as.o != 1/2)			print("error %d\n", __LINE__);
t29_as.p = &t29_ao[0];
++*t29_as.p;
*t29_as.p--;
if (t29_ao[0] != -1.0L || *t29_as.p != -1.0L)
    print("error %d\n", __LINE__);
class t29_c {
    auto o, *p;
    void check() {
	++this.o;
	this.o--;
	if (o != 0x80000000000000000)	print("error %d\n", __LINE__);
	o++;
	--o;
	if (this.o != 0x80000000000000000)
	    print("error %d\n", __LINE__);
	p = &o;
	++*p;
	if (this.o != 0x80000000000000001)
	    print("error %d\n", __LINE__);
	/* FIXME this is the proper C/C++ syntax */
	(*p)--;
	if (o != 0x80000000000000000)	print("error %d\n", __LINE__);
    }
} t29_ac = { o: 0x80000000000000000 };
t29_ac.check();
t29_ac.o++;
--t29_ac.o;
if (t29_ac.o != 0x80000000000000000)	print("error %d\n", __LINE__);
++t29_ac.o;
t29_ac.o--;
if (t29_ac.o != 0x80000000000000000)	print("error %d\n", __LINE__);
t29_ac.p = &t29_ac.o;
++*t29_ac.p;
*t29_ac.p--;
if (*t29_ac.p != 0x80000000000000000)	print("error %d\n", __LINE__);

/* test 30 - basic formatting tests */
print("+-------------------------------------+-------------------------------------+\n");
print("|%-37s|%37s|\n", "string", "string");
print("|%-37b|%37b|\n", 901, 901);
print("|%-37o|%37o|\n", 901, 901);
print("|%-37d|%37d|\n", 901, 901);
print("|%-37x|%37x|\n", 901, 901);
print("|%-75b|\n|%75b|\n", 0x8000000000000001, 0x8000000000000001);
print("|%-37o|%37o|\n", 0x8000000000000001, 0x8000000000000001);
print("|%-37d|%37d|\n", 0x8000000000000001, 0x8000000000000001);
print("|%-37x|%37x|\n", 0x8000000000000001, 0x8000000000000001);
print("|%-75b|\n|%75b|\n", 0x80000000/0x7fffffffff, 0x80000000/0x7fffffffff);
print("|%-37o|%37o|\n", 0x80000000/0x7fffffffff, 0x80000000/0x7fffffffff);
print("|%-37d|%37d|\n", 0x80000000/0x7fffffffff, 0x80000000/0x7fffffffff);
print("|%-37x|%37x|\n", 0x80000000/0x7fffffffff, 0x80000000/0x7fffffffff);
print("+-------------------------------------+-------------------------------------+\n");
print("|%-37b|%37b|\n", -901, -901);
print("|%-37o|%37o|\n", -901, -901);
print("|%-37d|%37d|\n", -901, -901);
print("|%-37x|%37x|\n", -901, -901);
print("|%-75b|\n|%75b|\n", -0x8000000000000001, -0x8000000000000001);
print("|%-37o|%37o|\n", -0x8000000000000001, -0x8000000000000001);
print("|%-37d|%37d|\n", -0x8000000000000001, -0x8000000000000001);
print("|%-37x|%37x|\n", -0x8000000000000001, -0x8000000000000001);
print("|%-75b|\n|%75b|\n", -0x80000000/0x7fffffffff, -0x80000000/0x7fffffffff);
print("|%-37o|%37o|\n", -0x80000000/0x7fffffffff, -0x80000000/0x7fffffffff);
print("|%-37d|%37d|\n", -0x80000000/0x7fffffffff, -0x80000000/0x7fffffffff);
print("|%-37x|%37x|\n", -0x80000000/0x7fffffffff, -0x80000000/0x7fffffffff);
print("+-------------------------------------+-------------------------------------+\n");
auto t30_a;
for (t30_a = 1; t30_a < 9; t30_a++)
    print("%*d\n", t30_a * 2 - 1, t30_a);
print("+--------+--------+--------+----------+--------+--------+--------+----------+\n");
print("|%8.2e|%8.2e|%8.2e|%10.2e", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2e|%-8.2e|%-8.2e|%-10.2e|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2E|%8.2E|%8.2E|%10.2E", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2E|%-8.2E|%-8.2E|%-10.2E|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2f|%8.2f|%8.2f|%10.2f", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2f|%-8.2f|%-8.2f|%-10.2f|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2g|%8.2g|%8.2g|%10.2g", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2g|%-8.2g|%-8.2g|%-10.2g|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2b|%8.2b|%8.2b|%10.2b", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2b|%-8.2b|%-8.2b|%-10.2b|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2o|%8.2o|%8.2o|%10.2o", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2O|%-8.2O|%-8.2O|%-10.2O|\n", 10.0, 1.0, 0.1, 0.01);
print("|%8.2x|%8.2x|%8.2x|%10.2x", 10.0, 1.0, 0.1, 0.01);
print("|%-8.2X|%-8.2X|%-8.2X|%-10.2X|\n", 10.0, 1.0, 0.1, 0.01);
print("+--------+--------+--------+----------+--------+--------+--------+----------+\n");
print("12345678901234567890\n");
print("%-5c%-5c%5c%5c\n", 'a', 'abc', 'a', 'abc');
print("+------------------------------------------------------------------------+\n");
for (t30_a = 0x8000000000fedcba; t30_a > -0x18000000002fc962e; t30_a -= 0x10000000001fdb974) {
    print("|%#72b|\n|%#72o|\n|%#72d|\n|%#72x|\n|%72b|\n|%72o|\n|%72d|\n|%72x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#72+b|\n|%#72+o|\n|%#72+d|\n|%#72+x|\n|%72+b|\n|%72+o|\n|%72+d|\n|%72+x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#72 b|\n|%#72 o|\n|%#72 d|\n|%#72 x|\n|%72 b|\n|%72 o|\n|%72 d|\n|%72 x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%+072b|\n|%+072o|\n|%+072d|\n|%+072x|\n|%072b|\n|%072o|\n|%072d|\n|%072x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#72B|\n|%#72O|\n|%#72D|\n|%#72X|\n|% 072b|\n|% 072o|\n|% 072d|\n|% 072x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#-72b|\n|%#-72o|\n|%#-72d|\n|%#-72x|\n|%-72b|\n|%-72o|\n|%-72d|\n|%-72x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#-72+b|\n|%#-72+o|\n|%#-72+d|\n|%#-72+x|\n|%-72+b|\n|%-72+o|\n|%-72+d|\n|%-72+x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("|%#-72 b|\n|%#-72 o|\n|%#-72 d|\n|%#-72 x|\n|%-72 b|\n|%-72 o|\n|%-72 d|\n|%-72 x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print("+------------------------------------------------------------------------+\n");
}
auto t30_b = 7/15;
print(" +--------------+--------+------+---------+----------+--------+------+------+\n");
for (t30_a = 15; t30_a > -45; t30_a -= 30, t30_b -= 14/15) {
    print("0|%#14b|%#8o|%#6d|%#9x|%10b|%8o|%6d|%6x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#14b|%#8o|%#6d|%#9x|%10b|%8o|%6d|%6x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("1|%#14+b|%#8+o|%#6+d|%#9+x|%10+b|%8+o|%6+d|%6+x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#14+b|%#8+o|%#6+d|%#9+x|%10+b|%8+o|%6+d|%6+x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("2|%#14 b|%#8 o|%#6 d|%#9 x|%10 b|%8 o|%6 d|%6 x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#14 b|%#8 o|%#6 d|%#9 x|%10 b|%8 o|%6 d|%6 x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("3|%+014b|%+08o|%+06d|%+09x|%010b|%08o|%06d|%06x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%+014b|%+08o|%+06d|%+09x|%010b|%08o|%06d|%06x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("4|%#14B|%#8O|%#6D|%#9X|% 010b|% 08o|% 06d|% 06x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#14B|%#8O|%#6D|%#9X|% 010b|% 08o|% 06d|% 06x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("5|%#-14b|%#-8o|%#-6d|%#-9x|%-10b|%-8o|%-6d|%-6x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#-14b|%#-8o|%#-6d|%#-9x|%-10b|%-8o|%-6d|%-6x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("6|%#-14+b|%#-8+o|%#-6+d|%#-9+x|%-10+b|%-8+o|%-6+d|%-6+x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#-14+b|%#-8+o|%#-6+d|%#-9+x|%-10+b|%-8+o|%-6+d|%-6+x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print("7|%#-14 b|%#-8 o|%#-6 d|%#-9 x|%-10 b|%-8 o|%-6 d|%-6 x|\n", t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a, t30_a);
    print(" |%#-14 b|%#-8 o|%#-6 d|%#-9 x|%-10 b|%-8 o|%-6 d|%-6 x|\n", t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b, t30_b);
    print(" +--------------+--------+------+---------+----------+--------+------+------+\n");
}
print("+----------+----------+----------+----------+\n");
print("|%10c|%#10c|%10s|%#10s|\n", '<\\\'>', '<\\\'>', "<\\\">", "<\\\">");
print("|%-10c|%#-10c|%-10s|%#-10s|\n", '<\\\'>', '<\\\'>', "<\\\">", "<\\\">");
print("+----------+----------+----------+----------+\n");
t30_a = 3.14159265358979323846;			/* math.h: M_PI */
t30_b = 3.1415926535897932384626433832795029L;	/* math.h: M_PIl */
print(" +------------------------------------------------------------------------+\n");
print("0|%#72b|\n |%#72b|\n |%#72b|\n |%#72b|\n |%#72o|\n |%#72o|\n |%#72o|\n |%#72o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#72d|\n |%#72d|\n |%#72d|\n |%#72d|\n |%#72x|\n |%#72x|\n |%#72x|\n |%#72x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72b|\n |%72b|\n |%72b|\n |%72b|\n |%72o|\n |%72o|\n |%72o|\n |%72o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72d|\n |%72d|\n |%72d|\n |%72d|\n |%72x|\n |%72x|\n |%72x|\n |%72x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("1|%#72+b|\n |%#72+b|\n |%#72+b|\n |%#72+b|\n |%#72+o|\n |%#72+o|\n |%#72+o|\n |%#72+o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#72+d|\n |%#72+d|\n |%#72+d|\n |%#72+d|\n |%#72+x|\n |%#72+x|\n |%#72+x|\n |%#72+x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72+b|\n |%72+b|\n |%72+b|\n |%72+b|\n |%72+o|\n |%72+o|\n |%72+o|\n |%72+o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72+d|\n |%72+d|\n |%72+d|\n |%72+d|\n |%72+x|\n |%72+x|\n |%72+x|\n |%72+x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("2|%#72 b|\n |%#72 b|\n |%#72 b|\n |%#72 b|\n |%#72 o|\n |%#72 o|\n |%#72 o|\n |%#72 o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#72 d|\n |%#72 d|\n |%#72 d|\n |%#72 d|\n |%#72 x|\n |%#72 x|\n |%#72 x|\n |%#72 x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72 b|\n |%72 b|\n |%72 b|\n |%72 b|\n |%72 o|\n |%72 o|\n |%72 o|\n |%72 o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%72 d|\n |%72 d|\n |%72 d|\n |%72 d|\n |%72 x|\n |%72 x|\n |%72 x|\n |%72 x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("3|%+072b|\n |%+072b|\n |%+072b|\n |%+072b|\n |%+072o|\n |%+072o|\n |%+072o|\n |%+072o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%+072d|\n |%+072d|\n |%+072d|\n |%+072d|\n |%+072x|\n |%+072x|\n |%+072x|\n |%+072x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%072b|\n |%072b|\n |%072b|\n |%072b|\n |%072o|\n |%072o|\n |%072o|\n |%072o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%072d|\n |%072d|\n |%072d|\n |%072d|\n |%072x|\n |%072x|\n |%072x|\n |%072x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("4|%#72B|\n |%#72B|\n |%#72B|\n |%#72B|\n |%#72O|\n |%#72O|\n |%#72O|\n |%#72O|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#72D|\n |%#72D|\n |%#72D|\n |%#72D|\n |%#72X|\n |%#72X|\n |%#72X|\n |%#72X|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |% 072b|\n |% 072b|\n |% 072b|\n |% 072b|\n |% 072o|\n |% 072o|\n |% 072o|\n |% 072o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |% 072d|\n |% 072d|\n |% 072d|\n |% 072d|\n |% 072x|\n |% 072x|\n |% 072x|\n |% 072x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("5|%#-72b|\n |%#-72b|\n |%#-72b|\n |%#-72b|\n |%#-72o|\n |%#-72o|\n |%#-72o|\n |%#-72o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#-72d|\n |%#-72d|\n |%#-72d|\n |%#-72d|\n |%#-72x|\n |%#-72x|\n |%#-72x|\n |%#-72x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-072b|\n |%-072b|\n |%-072b|\n |%-072b|\n |%-072o|\n |%-072o|\n |%-072o|\n |%-072o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-072d|\n |%-072d|\n |%-072d|\n |%-072d|\n |%-072x|\n |%-072x|\n |%-072x|\n |%-072x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("6|%#-72+b|\n |%#-72+b|\n |%#-72+b|\n |%#-72+b|\n |%#-72+o|\n |%#-72+o|\n |%#-72+o|\n |%#-72+o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#-72+d|\n |%#-72+d|\n |%#-72+d|\n |%#-72+d|\n |%#-72+x|\n |%#-72+x|\n |%#-72+x|\n |%#-72+x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-72+b|\n |%-72+b|\n |%-72+b|\n |%-72+b|\n |%-72+o|\n |%-72+o|\n |%-72+o|\n |%-72+o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-72+d|\n |%-72+d|\n |%-72+d|\n |%-72+d|\n |%-72+x|\n |%-72+x|\n |%-72+x|\n |%-72+x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("7|%#-72 b|\n |%#-72 b|\n |%#-72 b|\n |%#-72 b|\n |%#-72 o|\n |%#-72 o|\n |%#-72 o|\n |%#-72 o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%#-72 d|\n |%#-72 d|\n |%#-72 d|\n |%#-72 d|\n |%#-72 x|\n |%#-72 x|\n |%#-72 x|\n |%#-72 x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-72 b|\n |%-72 b|\n |%-72 b|\n |%-72 b|\n |%-72 o|\n |%-72 o|\n |%-72 o|\n |%-72 o|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" |%-72 d|\n |%-72 d|\n |%-72 d|\n |%-72 d|\n |%-72 x|\n |%-72 x|\n |%-72 x|\n |%-72 x|\n", t30_a, -t30_a, t30_b, -t30_b, t30_a, -t30_a, t30_b, -t30_b);
print(" +------------------------------------------------------------------------+\n");
print("+123456789012345678901234567890+\n");
print("|%*.*f%*.*f|\n", 10, 4, t30_a, 20, 8, t30_b);
print("|%-*.*f%-*.*f|\n", 10, 4, t30_a, 20, 8, t30_b);
print("|%*.*f%*.*f|\n", 10, 4, -t30_a, 20, 8, -t30_b);
print("|%-*.*f%-*.*f|\n", 10, 4, -t30_a, 20, 8, -t30_b);
print("%%% -72b%%\n%%% -72b%%\n%%% -72@b%%\n%%% -72@b%%\n%%% -72o%%\n%%% -72o%%\n%%% -72@o%%\n%%% -72@o%%\n", t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b);
print("%%% -72d%%\n%%% -72d%%\n%%% -72@d%%\n%%% -72@d%%\n%%% -72x%%\n%%% -72x%%\n%%% -72@x%%\n%%% -72@x%%\n", t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b);
print("%%% 72b%%\n%%% 72b%%\n%%% 72@b%%\n%%% 72@b%%\n%%% 72o%%\n%%% 72o%%\n%%% 72@o%%\n%%% 72@o%%\n", t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b);
print("%%% 72d%%\n%%% 72d%%\n%%% 72@d%%\n%%% 72@d%%\n%%% 72x%%\n%%% 72x%%\n%%% 72@x%%\n%%% 72@x%%\n", t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b, t30_b, -t30_b);
print("+------------------------+----------------+----------------+----------------+\n");
for (t30_a = 1e256L; t30_a > 1e-256L; t30_a /= 256) {
    print("|%-24.6@ b|%-16.6@ o|%-16.6 e|%-16.6@ x|\n", t30_a, t30_a, t30_a, t30_a);
    print("|%-24.6& b|%-16.6& o|%-16.6 g|%-16.6& x|\n", t30_a, t30_a, t30_a, t30_a);
}
print("+------------------------+----------------+----------------+----------------+\n");
for (t30_a = -1e256L; t30_a < -1e-256L; t30_a /= 256) {
    print("|%#24.6@ b|%#16.6@ o|%#16.6 e|%#16.6@ x|\n", t30_a, t30_a, t30_a, t30_a);
    print("|%#24.6& b|%#16.6& o|%#16.6 g|%#16.6& x|\n", t30_a, t30_a, t30_a, t30_a);
}
print("+------------------------+----------------+----------------+----------------+\n");
print("Format string is:\n"
      "%#0$s,\n"
      "arguments are (%d %d %d %d %s),\n"
      "evaluation is :%1$d:%#4$*2$o:%#x:%#b:.\n"
      "Storing bytes written so far %n... done!\n", 1, 2, 3, 4, &t30_a);
print("Wrote %d bytes\n", t30_a);
struct t30_s {
    int8_t   i8; uint8_t   u8; int16_t i16; uint16_t u16;
    int32_t i32; uint32_t u32; int64_t i64; uint64_t u64;
    float32_t f; float64_t d;  auto o;
} t30_sa = {};
print("i8%n", &t30_sa.i8);		print("           %d\n", t30_sa.i8);
print(".u8%n", &t30_sa.u8);		print("          %d\n", t30_sa.u8);
print("..i16%n", &t30_sa.i16);		print("        %d\n", t30_sa.i16);
print("...u16%n", &t30_sa.u16);		print("       %d\n", t30_sa.u16);
print("....i32%n", &t30_sa.i32);	print("      %d\n", t30_sa.i32);
print(".....u32%n", &t30_sa.u32);	print("     %d\n", t30_sa.u32);
print("......i64%n", &t30_sa.i64);	print("    %d\n", t30_sa.i64);
print(".......u64%n", &t30_sa.u64);	print("   %d\n", t30_sa.u64);
print("........f%n", &t30_sa.f);	print("    %d\n", t30_sa.f);
print(".........d%n", &t30_sa.d);	print("   %d\n", t30_sa.d);
print("........o%n", &t30_sa.o);	print("    %d\n", t30_sa.o);
int8_t  t30_i8[5] = {2: 5};	print("2:%n", &t30_i8[3]); print("%d - %d\n", t30_i8[3], t30_i8[2]);
uint8_t t30_u8[2] = {};		 print(":%n",  &t30_u8[1]); print("%d\n", t30_u8[1]);
int16_t t30_i16[5] = {};	 print("3::%n", &t30_i16[4]); print("%d\n", t30_i16[4]);
int16_t t30_u16[1] = {};	 print("4:::%n", &t30_u16[0]); print("%d\n", t30_u16[0]);
int32_t t30_i32[10] = {};	 print(":%n", &t30_i32[7]); print("%d\n", t30_i32[7]);
uint32_t t30_u32[4] = {};	 print("5::::%n", &t30_u32[2]); print("%d\n", t30_u32[2]);
int32_t t30_i64[3] = {};	 print("3::%n", &t30_i64[1]); print("%d\n", t30_i64[1]);
uint32_t t30_u64[5] = {};	 print("6:::::%n", &t30_u64[4]); print("%d\n", t30_u64[4]);
float32_t t30_f[8] = {};	 print("7::::::%n", &t30_f[6]); print("%d\n", t30_f[6]);
float64_t t30_d[3] = {};	 print("2:%n", &t30_d[2]); print("%d\n", t30_d[2]);
auto t30_o[] = { "abc", 2, 4.5L };
print("            %s %s %s\n", t30_o[0], t30_o[1], t30_o[2]);
print("2:%n5::%n11::::%n", &t30_o[0], &t30_o[1], &t30_o[2]);
print(" %s %s %s\n", t30_o[0], t30_o[1], t30_o[2]);
for (t30_b = 0; t30_b < 4; ++t30_b) {
    for (t30_a = 1; t30_a < 3; ++t30_a)
	print("%*c%*c%*c%*c\n",
	      t30_a, '>', (3 - t30_a) * 2 - 1, '<',
	      (t30_a * 2) - 1, '>', (3 - t30_a) * 2 - 1, '<');
}
/* the previous loop triggered a cse bug, that should have been
 * temporary, as a following ssa pass did not properly handle the
 * temporary (or temporaries) in the expression '(3 - a) * 2 -1'
 * adding also a function test to ensure it is also properly optimized
 */
void t30_t(void)
{
    auto a, b;
    for (b = 0; b < 4; ++b) {
	for (a = 1; a < 3; ++a)
	    print("%*c%*c%*c%*c\n",
		  a, '>', (3 - a) * 2 - 1, '<',
		  (a * 2) - 1, '>', (3 - a) * 2 - 1, '<');
    }
}
t30_t();

/* test 31 - basic scan tests */
/* FIXME this can cause major problems, that is, int8 and uint8 are
 * considered string constants, and may cause memory corruption due
 * to resizing it; and currently, there is a major problem of bad
 * reference from the ht_eliteral hash table, that hashes the vector->ptr
 * and not the vector object, and this way, can dereference unbound
 * memory in gc() */
//string t31_a = {};
string_t t31_a = new uint8_t[32];
auto t31_o, t31_c;
void t31_t(format, value)
{
    printf(t31_a, format, value);
    if (scanf(t31_a, format, &t31_o) != 1 || t31_o != value)
	print("error %d: %d\n", __LINE__, t31_c);
}
t31_c = 1;	t31_t("foo%bbar", 0xa55a);
t31_c = 2;	t31_t("--%b++", -4e32);
t31_c = 3;	t31_t("%#b", 255);
t31_c = 4;	t31_t("\xff%b/\xff", -3);
t31_c = 5;	t31_t("\r\n$%o99", 0277);
t31_c = 6;	t31_t("+-%%%o&#", 1e-2);
t31_c = 7;	t31_t("?%#o?", -0x8000000000000000);
t31_c = 8;	t31_t("<%d>", 1);
t31_c = 9;	t31_t("/%d/", -7);
t31_c = 10;	t31_t(" * %F * ", 0.25);
t31_c = 11;	t31_t("  0x%x  ", 0x8000000000000000);
t31_c = 12;	t31_t("0000 %x 0000", 3.1415926535897932384626433832795029L);
t31_c = 13;	t31_t("%%%%%c%%%%", '%');
t31_c = 14;	t31_t("foo%#cbar", 'abcdef');
t31_c = 15;	t31_t("\x00%C\000", -1);
t31_c = 16;	t31_t("'%#c'", 'abcdefghijklm\'\\NOPQRSTUVWXYZ');
t31_c = 17;	t31_t("foo%23cbar", 'long constant character');
t31_c = 18;	t31_t("1234%s  x", "foobar");
t31_c = 19;	t31_t("abc%#s", "a string \"with\" spaces");
if (scanf("abcasdfgHJKL:", "abc%[a-z]", &t31_o) != 1 || t31_o != "asdfg")
    print("error %d\n", __LINE__);
if (scanf("]abc-[", "]%[^]-]-[", &t31_o) != 1 || t31_o != "abc")
    print("error %d\n", __LINE__);
t31_c = 20;	t31_t("\xff%c\xff", 0xff);
if (scanf("a123b456d", "a%*db%dd", &t31_o) != 1 || t31_o != 456)
    print("error %d\n", __LINE__);
if (printf(t31_a, "%%%d**", 42) != 5)
    print("error %d\n", __LINE__);
auto t31_r;
if (printf(t31_a, "{ %5d }\n", -1) != 10 ||
    scanf(t31_a, "{ %5d }\n%n", &t31_o, &t31_r) != 1 ||
    t31_o != -1 || t31_r != 10)
    print("error %d\n", __LINE__);
if (printf(t31_a, "|%d|%s|", 123, "string") != 12 ||
   scanf(t31_a, "|%2$d|%1$5[^|]g|", &t31_o, &t31_r) != 2 ||
   t31_r != 123 || t31_o != "strin")
    print("error %d\n", __LINE__);
#define O_READ		1
#define O_WRITE		2
#define O_APPEND	4
#define O_NONBLOCK	8
#define O_BUFFERED	16
#define O_UNBUFFERED	32
#define SEEK_SET	0
#define SEEK_CUR	1
#define SEEK_END	2
if ((t31_a = open("test.txt", O_WRITE))) {
    if (printf(t31_a, "%b %o\n", 64, -128) != 13)
	print("error %d\n", __LINE__);
    if (printf(t31_a, "%d %x\n", -1, 1.5) != 7)
	print("error %d\n", __LINE__);
    close(t31_a);
}
else
    print("error %d\n", __LINE__);
if ((t31_a = open("test.txt", O_READ))) {
    if (scanf(t31_a, "%b %o\n", &t31_r, &t31_o) != 2 ||
	t31_r != 64 || t31_o != -128)
	print("error %d\n", __LINE__);
    if (scanf(t31_a, "%d %x\n", &t31_r, &t31_o) != 2 ||
	t31_r != -1 || t31_o != 1.5)
	print("error %d\n", __LINE__);
    close(t31_a);
}
else
    print("error %d\n", __LINE__);
if ((t31_a = open("test.txt", O_WRITE | O_APPEND))) {
    if (printf(t31_a, "%#b %#o\n", 255, -0x8000000000000001) != 36)
	print("error %d\n", __LINE__);
    if (printf(t31_a, "%#d %#x\n", 3.5L, 1e5) != 15)
	print("error %d\n", __LINE__);
    close(t31_a);
}
else
    print("error %d\n", __LINE__);
if ((t31_a = open("test.txt", O_READ))) {
    /* first 2 lines */
    if (scanf(t31_a, "%b %o\n", &t31_r, &t31_o) != 2 ||
	t31_r != 64 || t31_o != -128)
	print("error %d\n", __LINE__);
    if (scanf(t31_a, "%d %x\n", &t31_r, &t31_o) != 2 ||
	t31_r != -1 || t31_o != 1.5)
	print("error %d\n", __LINE__);
    /* appended data */
    if (scanf(t31_a, "%#b %#o\n", &t31_r, &t31_o) != 2 ||
	t31_r != 255 || t31_o != -0x8000000000000001)
	print("error %d\n", __LINE__);
    if (scanf(t31_a, "%#d %#x\n", &t31_r, &t31_o) != 2 ||
	t31_r != 3.5L || t31_o != 1e5)
	print("error %d\n", __LINE__);
    /* there is nothing to read, just ensure it "properly" fails */
    if ((t31_r = scanf(t31_a, "%s", &t31_o)) != 0)
	print("error %d\n", __LINE__);
    close(t31_a);
#if 0		/* now it generates a fatal error (should be an exception) */
    /* once more, but now with file closed */
    if ((t31_r = scanf(t31_a, "%s", &t31_o)) != 0)
	print("error %d\n", __LINE__);
#endif
}
else
    print("error %d\n", __LINE__);
/* test.txt contents should be:
-%<-
1000000 -200
-1 1.8
0b11111111 -01000000000000000000001
3.2l 0x186a0.0
-%<-
 */
if ((t31_a = open("test.txt", O_READ|O_WRITE))) {
    /* seek to start of second line */
    if ((t31_o = seek(t31_a, 13, SEEK_SET)) != 13)
	print("error %d\n", __LINE__);
    /* invert signs of entries in second line and print it */
    if (printf(t31_a, "%d %x\n", 1, -1.5) != 7)
	print("error %d\n", __LINE__);
    if ((t31_o = seek(t31_a, -7, SEEK_CUR)) != 13)
	print("error %d\n", __LINE__);
    if ((t31_o = seek(t31_a, -15, SEEK_END)) != 56)
	print("error %d\n", __LINE__);
    /* not reading ending newline */
    if (scanf(t31_a, "%#d %#x", &t31_r, &t31_o) != 2 ||
	t31_r != 3.5L || t31_o != 1e5)
	print("error %d\n", __LINE__);
    /* read the ending newline */
    if (scanf(t31_a, "%3c%n", &t31_o, &t31_r) != 1 ||
	t31_o != '\n' || t31_r != 1)
	print("error %d\n", __LINE__);
    /* seek back to position of ending newline */
    if ((t31_o = seek(t31_a, -1, SEEK_END)) != 70)
	print("error %d\n", __LINE__);
    /* close file */
    close(t31_a);
#if 0		/* now it generates a fatal error (should be an exception) */
    /* now must fail to read the ending newline */
    if (scanf(t31_a, "%3c%n", &t31_o, &t31_r) != 0)
	print("error %d\n", __LINE__);
#endif
}
else
    print("error %d\n", __LINE__);
t31_a = new uint8_t[32];
printf(t31_a, "%d", 12345);
if (scanf(t31_a, "%#s", &t31_o) == 1)
    print("error %d\n", __LINE__);
if (scanf(t31_a, "%#c", &t31_o) == 1)
    print("error %d\n", __LINE__);
if (scanf(t31_a, "%d", &t31_o) != 1 || t31_o != 12345)
    print("error %d\n", __LINE__);

/* test 32 - macros */
#define max(a, b) ((a) > (b) ? (a) : (b))
/*	==> if (((1) > (2) ? (1) : (2)) != 2) */
if (max(1, 2) != 2)			print("error %d\n", __LINE__);
/*	==> if (((((-1) > (3) ? (-1) : (3))) > (((2) > (1) ? (2) : (1))) ? (((-1) > (3) ? (-1) : (3))) : (((2) > (1) ? (2) : (1)))) != 2) */
if (max(max(-1, 3), max(2, 1)) != 3)	print("error %d\n", __LINE__);
/*	==> if (((2 + 1) > (((4.2) > (9/2) ? (4.2) : (9/2))) ? (2 + 1) : (((4.2) > (9/2) ? (4.2) : (9/2)))) != 9/2) */
if (max(2 + 1, max(4.2, 9 / 2)) != 9/2)	print("error %d\n", __LINE__);
#define plus	+
#define times	*
if (max(3 plus 3, 3 times 3) != 9)	print("error %d\n", __LINE__);
/* random tests from examples in cpp.info */
#define t32_NUMBERS	1, \
			2, \
			3
/*	==>
int t32x[] = { 1, 2, 3 }; */
int32_t t32x[] = { t32_NUMBERS };
if (t32x[0] != 1 || t32x[1] != 2 || t32x[2] != 3)
    print("error %d\n", __LINE__);
#define t32_TABLESIZE	t32_BUFSIZE
#define t32_BUFSIZE	1024
/*	==> if (1024 != 1024) */
if (t32_TABLESIZE != 1024)		print("error %d\n", __LINE__);
#undef t32_BUFSIZE
#define t32_BUFSIZE	37
/*	==> if (37 != 37) */
if (t32_TABLESIZE != 37)		print("error %d\n", __LINE__);
/*	==> if (37 != 37) */
if (t32_TABLESIZE != t32_BUFSIZE)	print("error %d\n", __LINE__);
/* expected behavior when a macro expansion would be recursive
 * (obfuscating and confusing usage...) */
auto t32_foo = 2;
#define t32_foo		(4 + t32_foo)
/*	==> if ((4 + t32_foo) != 6) */
if (t32_foo != 6)			print("error %d\n", __LINE__);
/*
#define x (4 + y)
#define y (2 * x)
x    ==> (4 + y)
     ==> (4 + (2 * x))
y    ==> (2 * x)
     ==> (2 * (4 + y))
another obfuscating and confusing usage, that would just generate an
error if there are no 'x' and 'y' variables
 */
auto t32_x = 5;
auto t32_y = 2;
#define t32_x		(4 + t32_y)
#define t32_y		(2 * t32_x)
/*	==> if ((4 + (2 * t32_x)) != 14) */
if (t32_x != 14)			print("error %d\n", __LINE__);
/*	==> if ((2 * (4 + t32_y)) != 12) */
if (t32_y != 12)			print("error %d\n", __LINE__);
auto t32_a = 1, t32_b = 2;
#undef t32_foo
#define t32_foo		(t32_a, t32_b)
#define t32_bar(x)	t32_lose(x)
#define t32_lose(x)	(1 + (x))
/* expected expansion is:
	bar(foo)
   foo expands:
	(a, b)
   bar expands:
	lose((a, b))
    lose expands:
	(1 + ((a, b)))
this sample shows that the definition:
#define foo a, b
would cause an error when it would be evaluated as 'lose' argument, as
the 'lose' macro expects only one argument. But when defined as:
#define foo (a, b)
the parenthesis transform the 'foo' expansion in a single argument.
 */
/*	==> if ((1 + ((t32_a, t32_b))) != 3) */
if (t32_bar(t32_foo) != 3)		print("error %d\n", __LINE__);
/* not testing reported error line, just an adaptation of:
3.10.7 Newlines in Arguments
for a random test.
FIXME need to check the current behavior, as it may not report line number
on errors like cpp, as that depends on when the "sampling" is done, on
eparser.c, when a "toplevel" expression is added to eparser.c:hash_annotation
 */
#undef t32_x
t32_x = 10;
#define t32_ignore_second_arg(a,b,c) a; c
/*	==>
t32_x += 10; t32_x += 10 */
t32_ignore_second_arg(t32_x += 10,
		      t32_x += 10,	// ignored
		      t32_x += 10);	// sample error...
if (t32_x != 30)			print("error %d\n", __LINE__);
#define t32_set_to_1
t32_x = 0;
#ifdef t32_set_to_1
t32_x = 1;
#endif
if (t32_x != 1)				print("error %d\n", __LINE__);
#undef t32_set_to_1
t32_x = 0;
#ifdef t32_set_to_1
t32_x = 1;
#else
t32_x = 10;
#endif
/*	==> if ( 10 != 10) */
if (t32_x != 10)			print("error %d\n", __LINE__);
/* this will work differently because tokens are not rescanned
10.2 Traditional macros
just another random test, and expected result, without warnings,
as it is not mean't to be compatible with "traditional" mode, just
to support well "defined behavior", and don't crash gratuitously on
recursive, directly or indirectly, macro expansions */
#undef t32_foo
t32_foo = 1;
#define t32_PLUS	+
#define t32_INC(x)	t32_PLUS+x
/* instead of expanding to '++t32_foo'
it expands to (the equivalent of) '+ + t32_foo' */
/*	==>
+ + t32_foo */
t32_INC(t32_foo);
if (t32_foo != 1)			print("error %d\n", __LINE__);
#undef t32_x
#undef t32_y
t32_x = -1.5;
#define t32_foo(x)	x, "x"
string_t t32_str = new (uint8_t[16]);
/*	==>
printf(t32_str, "%d %#s\n", t32_x, "x"); */
printf(t32_str, "%d %#s\n", t32_foo(t32_x));
scanf(t32_str, "%d %#s\n", &t32_y, &t32_x);
if (t32_x != "x" || t32_y != -1.5)	print("error %d\n", __LINE__);
#undef t32_foo
#define t32_foo
/*	==> if (- 10 != -10) */
if (t32_foo - 10 != -10)		print("error %d\n", __LINE__);
#warning warning preprocessor test
#undef t32_foo
#define t32_foo()	2	/* function macro without arguments */
/*	==> if (2 + 2 != 4) */
if (t32_foo() + t32_foo() != 4)		print("error %d\n", __LINE__);
/* self referential macro, that is useful
to check for a symbol/constant using #ifdef */
#undef t32_foo
#define t32_foo		t32_foo
#ifdef t32_foo
t32_foo = -1;
#else
t32_foo = 1;
#endif
/*	==> if (-1 != -1) */
if (t32_foo != -1)			print("error %d\n", __LINE__);
#undef t32_foo
#define t32_foo(x)	t32_ ## x
t32_x = -1, t32_y = 1;
/*	==> if (t32_x + t32_y != 0) */
if (t32_foo(x) + t32_foo(y) != 0)	print("error %d\n", __LINE__);
/* stringification is not a "verbatim" stringification */
/* adaptation of example from info cpp:
3.4 Stringification
 */
#define t32_WARN_IF(EXP) \
    do { if (EXP) \
	printf(t32_str, "%s", "Warning: " #EXP "\n"); } \
    while (0)
t32_x = 0;
/*	==>
    do { if (t32_x == 0) printf(t32_str, "%s", "Warning: "  "t32_x == 0" "\n"); } while (0); */
t32_WARN_IF (t32_x == 0);
if (t32_str != "Warning: t32_x == 0\n")	print("error %d\n", __LINE__);
#undef t32_foo
#define t32_xstr(s) t32_astr(s)
#define t32_astr(s) #s
#define t32_foo 4
printf(t32_str, "%s", t32_astr(t32_foo));
if (t32_str != "t32_foo")		print("error %d\n", __LINE__);
/*	==>
printf(t32_str, "%s", "4"); */
printf(t32_str, "%s", t32_xstr(t32_foo));
if (t32_str != "4")			print("error %d\n", __LINE__);
#undef t32_foo
/*	==>
printf(t32_str, "%s", "\"s \\\"t\\\" r\""); */
printf(t32_str, "%s", t32_xstr("s \"t\" r"));
scanf(t32_str, "%#s", &t32_foo);
if (t32_str != "\"s \\\"t\\\" r\"" || t32_foo != "s \"t\" r")
    print("error %d\n", __LINE__);
#define x	y
#define y	x
#define X	_Y_	// this was entering an infinite loop due to a
			// simple/dumb bug expecting _Y_ to also be a macro...
#define Y	_X_
printf(t32_str, "%s", t32_astr((x||y)&&X^Y));
#undef Y
#undef X
#undef y
#undef x
if (t32_str != "( x || y ) && X ^ Y")	print("error %d\n", __LINE__);
/* slightly based on sample at:
3.5 Concatenation
*/
struct t32_command {
    string_t	name;
    auto	value;
};
#define t32_COMMAND(NAME)	{ #NAME, t32_##NAME }
t32_x = 7; t32_y = 15;
struct t32_command t32c[] = {
    t32_COMMAND(x),
    t32_COMMAND(y),
};
t32_x = t32_y = 0;
if (t32c[0].name != "x" || t32c[0].value != 7 ||
    t32c[1].name != "y" || t32c[1].value != 15)
    print("error %d\n", __LINE__);
#define t32_printf(...)		printf(__VA_ARGS__)
/*	==>
printf(t32_str, %d %d", 1, 2);
*/
t32_printf(t32_str, "%d %d", 1, 2);
if (t32_str != "1 2")			print("error %d\n", __LINE__);
#undef t32_printf
#define t32_printf(format, ...)	printf(t32_str, format, __VA_ARGS__)
/*	==>
printf(t32_str, %s", "Success\n");
*/
t32_printf("%s", "Success\n");
if (t32_str != "Success\n")		print("error %d\n", __LINE__);
#undef t32_printf
/* check ,## */
#define t32_printf(format, ...)	printf(t32_str, format, ## __VA_ARGS__)
/*	==>
printf(t32_str, "it works!\n");		<- comma removed as __VA_ARGS__ is null
*/
t32_printf("it works!\n");
if (t32_str != "it works!\n")		print("error %d\n", __LINE__);
#undef t32_printf
#define t32_printf(format, arg1, arg2) printf(t32_str, format, ## arg1, ## arg2)
t32_printf("%d", , 1);
if (t32_str != "1")			print("error %d\n", __LINE__);
t32_printf("%d", 0, );
if (t32_str != "0")			print("error %d\n", __LINE__);
t32_printf("foobar", , );
if (t32_str != "foobar")		print("error %d\n", __LINE__);
/* check to ensure left and right side of ## are not macro expanded */
#define t32_	t32
#define foo	foo_
#define t32_set_foo(prefix, sufix, value)	prefix##sufix = value
auto t32foo_ = -1;
t32_foo = t32foo_;
/*	==>
t32_foo = 10;
	and not
t32foo_ = 10;
	last one would happen if fully expanded macro arguments were
	used with '##'
*/
t32_set_foo(t32_, foo, 10);
if (t32_foo != 10 || t32foo_ != -1)	print("error %d\n", __LINE__);
print("hello from %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);
/* FIXME: using uppercase argument names because 'function'
 * is a builtin ``typedef auto (*function)(...);''
 */
void t32_f(FILE, FUNCTION, LINE)
{
    print("hello again, from %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);
    print("I was called from %s:%s:%d\n", FILE, FUNCTION, LINE);
}
t32_f(__FILE__, __FUNCTION__, __LINE__);
/* examples from:
3.10.1 Misnesting
*/
/* this one showed a bug, where it would attempt to read more data then
 * available, when evaluating a macro argument, what would confuse the
 * parser, that is, it should not read past the `twice' token when
 * evaluating `call_with_1' argument */
#define twice(x) (2*(x))
#define call_with_1(x) x(1)
/*	==> if ((2*(1)))	<- eparser.c simplifies to `if (2)' */
if (call_with_1 (twice) != 2)		print("error %d\n", __LINE__);
#define strange(format)	printf(t32_str, format,
/*	==>
printf(t32_str, "%d", 45); */
strange("%d") 45);
if (t32_str != "45")			print("error %d\n", __LINE__);
#define new_var(prefix)		prefix ## __COUNTER__
if (t32_xstr(new_var(foo)) != "foo0")	print("error %d\n", __LINE__);
print("Hello again! Now at line %d, date is %s, and time is %s.\n",
      __LINE__, __DATE__, __TIME__);
#if 0
this line is never parsed
#endif
#if defined (__vax__) || defined (__ns16000__)
print("Hi there __vax__ or __ns16000__!\n");
#endif
#if defined BUFSIZE && BUFSIZE >= 1024
print("BUFSIZE && BUFSIZE >= 1024");
#endif
#if BUFSIZE >= 1024		/* BUFSIZE expands to 0 in conditional */
print("BUFSIZE >= 1024");
#endif
#if !defined(NEVER_DEFINED_BEFORE)
printf(t32_str, "!defined(NEVER_DEFINED_BEFORE)");
#else
printf(t32_str, "???");
#endif
if (t32_str != "!defined(NEVER_DEFINED_BEFORE)")
    print("error %d\n", __LINE__);
#define ONE	1
#define TWO	two
#define two	2
#define THREE	ThReE
#define ThReE	three
#define three	3
#define FOUR	Four
#define Four	fouR
#define fouR	four
#define four	4
#define FIVE	Five
#define Five	fIve
#define fIve	fiVe
#define fiVe	five
#define five	5
#if ONE + ONE != TWO
printf(t32_str, "ONE + ONE != TWO");
#elif ONE << ONE == THREE || TWO + TWO == FIVE
printf(t32_str, "ONE << ONE == THREE || TWO + TWO == FIVE");
#elif FIVE ^ FOUR == THREE + - ONE / FOUR
printf(t32_str, " FIVE ^ FOUR != THREE + - ONE / FOUR");
#else
#  ifndef ONE
#  else
printf(t32_str, "ONE");
#  endif
#endif
if (t32_str != "ONE")			print("error %d\n", __LINE__);
#if (TWO + THREE) * TWO != 10
print("error %d\n", __LINE__);
#endif
#if 0
not parsed
/*
#else
also not parsed
#endif
again not parsed */
#endif
#if 1
1;
#else
hello!
#endif
#undef foo
#define foo "foo"
#if "foo" != foo
print("\"foo\" != foo\n");
#endif
#if "foo"
printf(t32_str, "%s", foo);
#else
printf(t32_str, "bar");
#endif
if (t32_str != foo)			print("error %d\n", __LINE__);
#undef foo
#define foo(a, b, c)	a, b, c
#define foo(a, b, c)	a, b, c	/* should not warn here */
#undef foo
#define foo	1, 2, 3
#define foo	1, 2, 3		/* neither here */
#if ONE + \
	ONE + ONE \
	+ ONE + ONE \
	!= TWO \
	+ TWO + \
	ONE
printf(t32_str, "1+1+1+1+1 != 5");
#elif (FIVE + FIVE \
	+ FIVE + FIVE \
	+ FIVE \
	) /* truncation operation followed by line concatenation */\\
	FIVE != ONE + TWO \
	+ THREE + FOUR - FIVE
printf(t32_str, "(5+5+5+5+5)\\5 != 1+2+3+4-5");
#elif FIVE == five * Five / (2 + three)
printf(t32_str, "%d", FIVE);	/* expected result */
#elif FIVE == "5"
printf(t32_str, "5 == \"5\"");
#elif ONE
printf(t32_str, "1");		/* correct, but should just skip it */
#else
printf(t32_str, "???");
#endif
if (t32_str != t32_xstr(FIVE))		print("error %d\n", __LINE__);
#if TWO + TWO != FOUR
    printf(t32_str, "2+2 != 4");
#  if ONE + ONE != TWO
	printf(t32_str, "1+1 != 2");
#  endif
#elif ONE + ONE == TWO		/* <= use this condition */
#  if ONE ^ TWO != 1 | TWO
	printf(t32_str, "1^2 != 1|2");
#  elif THREE & ONE == FOUR >> TWO	/* <= use this condition */
	printf(t32_str, "3&1 == 4>>2");	/* <<<<< expected result */
#  elif (ONE || 0) && FOUR + THREE && 1 - ONE
	printf(t32_str, "(1||0) && 4+3 && 1-1");
#  elif ONE + ONE - TWO == 0		/* correct but already choosen branch */
	printf(t32_str, "1+1-2 == 0");
#  else
	printf(t32_str, "????");
#  endif
#elif TWO + TWO == FOUR		/* <= correct, but already choosen a branch */
    printf(t32_str, "2+2 = 4");
#elif 1 + ONE == two		/* <= correct, but already choosen a branch */
    printf(t32_str, "1+1 == 2");
#else				/* also "correct", but should not execute */
    printf(t32_str, "???");
#endif
if (t32_str != "3&1 == 4>>2")		print("error %d\n", __LINE__);
#if 1
#  if 1
#    if 1
	    printf(t32_str, "1");
#    elif 1
	    printf(t32_str, "ops1");
#    elif 1
	    printf(t32_str, "ops2");
#    else
	    printf(t32_str, "ops3");
#    endif
#  elif 1
	printf(t32_str, "ops4");
#  elif 1
	printf(t32_str, "ops5");
#  else
	printf(t32_str, "ops6");
#  endif
#elif 1
    printf(t32_str, "ops7");
#elif 1
    printf(t32_str, "ops8");
#else
    printf(t32_str, "ops9");
#endif
if (t32_str != "1")			print("error %d\n", __LINE__);
#if 0
#  if 1
	printf(t32_str, "ops1");
#  elif 0
	printf(t32_str, "ops2");
#  else
	printf(t32_str, "ops3");
#  endif
#elif 0
#  if 1
	printf(t32_str, "ops4");
#  elif 1
	printf(t32_str, "ops5");
#  else
	printf(t32_str, "ops6");
#  endif
#else
#  if 0
	printf(t32_str, "ops7");
#  elif 0
#    if 1
	    printf(t32_str, "ops8");
#    else
	    printf(t32_str, "ops9");
#    endif
#  else
#    if 0
	    printf(t32_str, "ops10");
#    else
#      if 1
		printf(t32_str, "5");
#      elif 1
		printf(t32_str, "ops11");
#      else
		printf(t32_str, "ops12");
#      endif
#    endif
#  endif
#endif
if (t32_str != "5")			print("error %d\n", __LINE__);
#if 1
# if 0
#  if 3
#   if 4
#    if 5
printf(t32_str, "ops1");		print("error %d\n", __LINE__);
#     if 6
#      if 7
#       if 8
#        if 9
#         if 10
printf(t32_str, "ops2");		print("error %d\n", __LINE__);
#         endif
#        endif
#       endif
#      endif
#     endif
#    endif
#   endif
#  endif
# elif 2
#  if 3
#   if 4
#    if 5
#     if 0
#      if 7
printf(t32_str, "ops3");		print("error %d\n", __LINE__);
#       if 8
#        if 9
#         if 10
printf(t32_str, "ops4");		print("error %d\n", __LINE__);
#         endif
#        endif
#       endif
#      endif
#     elif 6
#      if 7
#       if 8
#        if 9
#         if 10
		printf(t32_str, "10");
#         endif
#        endif
#       endif
#      endif
#     elif 6
#      if 7
		printf(t32_str, "ops5");
#       if 8
#        if 9
		printf(t32_str, "ops6");
#         if 10
		printf(t32_str, "ops7");
#         endif
#        endif
#       endif
#      endif
#     else
#      if 7
		printf(t32_str, "ops8");
#       if 8
#        if 9
#         if 10
		printf(t32_str, "ops9");
#	  elif 1
		printf(t32_str, "ops10");
#	  elif 1
		printf(t32_str, "ops11");
#         endif
#        endif
#       endif
#      endif
#     endif
#    endif
#   endif
#  endif
# endif
#endif
if (t32_str != "10")			print("error %d\n", __LINE__);
#if 0
"#endif"
#endif

/* test33 - varargs */
/* this is a more complete set of tests, as the previous varargs implementation
 * improperly considered variables of the previous function as varargs, and
 * was not properly tested because the tests used toplevel functions */
auto t33_f0(...)		{ return sizeof(...); }
auto t33_f1(v1, ...)		{ return sizeof(...); }
auto t33_f2(v1, v2, ...)	{ return sizeof(...); }
auto t33_f3(v1, v2, v3, ...)	{ return sizeof(...); }
void t33_f_t1(void)
{
    auto v1 = 1, v2 = 2, v3 = 3;
    if (t33_f0(v1, v2, v3) != 3)	print("error %d\n", __LINE__);
    if (t33_f1(v1, v2, v3) != 2)	print("error %d\n", __LINE__);
    if (t33_f2(v1, v2, v3) != 1)	print("error %d\n", __LINE__);
    if (t33_f3(v1, v2, v3) != 0)	print("error %d\n", __LINE__);
    if (t33_f0() != 0)			print("error %d\n", __LINE__);
    if (t33_f1(v1) != 0)		print("error %d\n", __LINE__);
    if (t33_f2(v1, v2) != 0)		print("error %d\n", __LINE__);
    if (t33_f3(v1, v2, v3) != 0)	print("error %d\n", __LINE__);
    if (t33_f0(v1) != 1)		print("error %d\n", __LINE__);
    if (t33_f1(v1, v2) != 1)		print("error %d\n", __LINE__);
    if (t33_f2(v1, v2, v3) != 1)	print("error %d\n", __LINE__);
    if (t33_f3(v1, v2, v3, -1) != 1)	print("error %d\n", __LINE__);
}
t33_f_t1();
class t33_c_t {
    auto f0(...) {
	auto r = 0, n = sizeof(...);
	for (--n; n >= 0; --n)
	    r += ...[n];
	return r;
    }
    auto f1(v1, ...) {
	auto r = v1, n = sizeof(...);
	for (--n; n >= 0; --n)
	    r += ...[n];
	return r;
    }
    auto f2(v1, v2, ...) {
	auto r = v1 + v2, n = sizeof(...);
	for (--n; n >= 0; --n)
	    r += ...[n];
	return r;
    }
};
void t33_f_t2(t33_c_t c)
{
    auto x= 1, y = 2, z = 3;
    if (c.f0(x, y, z) != 6)		print("error %d\n", __LINE__);
    if (c.f1(x, y, z) != 6)		print("error %d\n", __LINE__);
    if (c.f2(x, y, z) != 6)		print("error %d\n", __LINE__);
}
t33_f_t2(new(t33_c_t));
void t33_fn(...)
{
    auto n = sizeof(...);
    switch (n) {
	case 0:
	    t33_fn(1, 2);
	    break;
	case 1:
	    t33_fn(1, 2, 3, 4);
	    break;
	case 2:
	    t33_fn(1, 2, 3, 4, 5);
	    break;
	case 3:
	    break;
	case 4:
	    t33_fn(1, 2, 3);
	    break;
	case 5:
	    t33_fn(1, 2, 3, 4, 5, 6);
	    break;
	case 6:
	    t33_fn(1);
	    break;
	default:
	    print("error %d\n", __LINE__);
    }
    if (n != sizeof(...))		print("error %d\n", __LINE__);
}
void t33_f_t3(void)
{
    t33_fn();
}
t33_f_t3();

/* test34 - exceptions */
void t34_f_1() {
    try {
	throw 20;
    }
    catch (e) {
	print("An exception occurred. Exception Nr. %d\n", e);
    }
}
t34_f_1();
//--
try {
    try {
	throw "string";
    }
    catch (e) {
	print("Innermost catch: %s\n", e);
	throw;
    }
}
catch (e) {
    print("Topmost catch: %s\n", e);
}
//--
class t34_exception {
    string_t what() {
	return "My exception happened";
    }
} t34_e = {};
try {
    throw t34_e;
}
catch (t34_exception e) {
    print("%s\n", e.what());
}
//--
/* this is derived from a sample at
 *	http://www.parashift.com/c++-faq-lite/exceptions.html
 */
void t34_handle_exception_0() {
    try {
	throw;
    }
    catch (t34_exception e) {
	print("(1) handled typed exception: %s\n", e.what());
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
void t34_f2() {
    try {
	throw t34_e;
    }
    catch (e) {
	t34_handle_exception_0();
    }
}
t34_f2();
/* example above, doing it in an arguably clearer syntax */
void t34_handle_exception_1(except) {
    try {
	throw except;
    }
    catch (t34_exception e) {
	print("(2) handled typed exception: %s\n", e.what());
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
void t34_f3() {
    try {
	throw t34_e;
    }
    catch (e) {
	t34_handle_exception_1(e);
    }
}
t34_f3();
//--
/* expected result is:
 * --
 * in try block, throwing 5...
 * in always block...
 * in typed catch: 5
 */
try {
    print("--\nin try block, throwing 5...\n");
    throw 5;
}
always {
    print("in always block...\n");
}
catch (int64_t e) {
    print("in typed catch: %d\n", e);
}
catch (e) {
    print("error %d\n", __LINE__);
}
//--
/* expected result is:
 * --
 * in top try...
 * in inner try, throwing 3...
 * in inner always, throwing 2...
 * in top always...
 * in top typed catch: 2
 */
try {
    print("--\nin top try...\n");
    try {
	print("in inner try, throwing 3...\n");
	throw 3;
    }
    always {
	print("in inner always, throwing 2...\n");
	/* this should throw to the top try */
	throw 2;
    }
    catch (int64_t e) {
	print("in inner typed catch: %d\n", e);
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
always {
    print("in top always...\n");
}
catch (int64_t e) {
    print("in top typed catch: %d\n", e);
}
catch (e) {
    print("error %d\n", __LINE__);
}
//-- previous test, now without throwing in inner always
/* expected result is:
 * --
 * in top try...
 * in inner try, throwing 3...
 * in inner always...
 * in inner typed catch: 3
 * in top always...
 */
try {
    print("--\nin top try...\n");
    try {
	print("in inner try, throwing 3...\n");
	throw 3;
    }
    always {
	print("in inner always...\n");
    }
    catch (int64_t e) {
	print("in inner typed catch: %d\n", e);
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
always {
    print("in top always...\n");
}
catch (int64_t e) {
    print("in top typed catch: %d\n", e);
}
catch (e) {
    print("error %d\n", __LINE__);
}
//-- previous test, now without throwing any exception
/* expected result is:
 * --
 * in top try...
 * in inner try...
 * in inner always...
 * in top always...
 */
try {
    print("--\nin top try...\n");
    try {
	print("in inner try...\n");
    }
    always {
	print("in inner always...\n");
    }
    catch (int64_t e) {
	print("error %d\n", __LINE__);
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
always {
    print("in top always...\n");
}
catch (int64_t e) {
    print("error %d\n", __LINE__);
}
catch (e) {
    print("error %d\n", __LINE__);
}
//-- now throwing null (or zero) to resume try block and dont test catch entries
/* expected result is:
 * --
 * in top try...
 * in inner try..., throwing null...
 * in inner always...
 * in top always...
 */
try {
    print("--\nin top try...\n");
    try {
	print("in inner try..., throwing null...\n");
	throw null;
    }
    always {
	print("in inner always...\n");
    }
    catch (int64_t e) {
	print("error %d\n", __LINE__);
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
always {
    print("in top always...\n");
}
catch (int64_t e) {
    print("error %d\n", __LINE__);
}
catch (e) {
    print("error %d\n", __LINE__);
}
//-- now throwing zero (or null) to resume try block and dont test catch entries
/* In this case, the inner always is not executed because the inner try
 * is never executed.
 * expected result is:
 * --
 * in top try.., throwing 0...
 * in top always...
 */
try {
    print("--\nin top try..., throwing 0...\n");
    throw 0;
    try {
	print("error %d\n", __LINE__);
    }
    always {
	print("error %d\n", __LINE__);
    }
    catch (int64_t e) {
	print("error %d\n", __LINE__);
    }
    catch (e) {
	print("error %d\n", __LINE__);
    }
}
always {
    print("in top always...\n");
}
catch (int64_t e) {
    print("error %d\n", __LINE__);
}
catch (e) {
    print("error %d\n", __LINE__);
}
print("--\n");

/* test35 - simple test for uncommon label usage, before a statement;
 * the proper usage is of course to move the label inside the block,
 * but this usage may be useful with macros
 * Added proper parser code when reading:
 *	http://www.halfbakery.com/idea/C_20exception_20handling_20macros
 */
auto t35_i = 0;
goto t35_label;
while (0) t35_label:
{
    if (++t35_i >= 10) break;
    else goto t35_label;
}
if (t35_i != 10)			print("error %d\n", __LINE__);

/* test36 - test for statically typed variables */
int8_t		t36_i8;		uint8_t		t36_u8;
int16_t		t36_i16;	uint16_t	t36_u16;
int32_t		t36_i32;	uint32_t	t36_u32;
int64_t		t36_i64;	uint64_t	t36_u64;
float32_t	t36_f32;	float64_t	t36_f64;
auto		t36_v;
struct t36_t {
    int8_t	i8;	uint8_t		u8;
    int16_t	i16;	uint16_t	u16;
    int32_t	i32;	uint32_t	u32;
    int64_t	i64;	uint64_t	u64;
    float32_t	f32;	float64_t	f64;
    auto	v;
};
void t36_test(v,
	      int8_t	i8,  uint8_t	u8,
	      int16_t	i16, uint16_t	u16,
	      int32_t	i32, uint32_t	u32,
	      int64_t	i64, uint64_t	u64,
	      float32_t	f32, float64_t	f64,
	      truncate)
{
    t36_t t = {
	v, v, v, v, v, v, v, v, truncate ? f32 : v, truncate ? f64 : v, v
    };
    if (v   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, v,   t.v);
    if (i8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, i8,  t.i8);
    if (u8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, u8,  t.u8);
    if (i16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, i16, t.i16);
    if (u16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, u16, t.u16);
    if (i32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, i32, t.i32);
    if (u32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, u32, t.u32);
    if (i64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, i64, t.i64);
    if (u64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, u64, t.u64);
    if (truncate) {
	if (trunc(f32) != trunc(t.f32))
	    print("error %d: f32 %#d %d %d\n", __LINE__, v, f32, t.f32);
	if (trunc(f64) != trunc(t.f64))
	    print("error %d: f64 %#d %d %d\n", __LINE__, v, f64, t.f64);
    }
    else {
	if (f32 != t.f32)
	    print("error %d: f32 %#d %d %d\n", __LINE__, v, f32, t.f32);
	if (f64 != t.f64)
	    print("error %d: f64 %#d %d %d\n", __LINE__, v, f64, t.f64);
    }
}
void t36_test_args(int8_t	i8,  uint8_t	u8,
		   int16_t	i16, uint16_t	u16,
		   int32_t	i32, uint32_t	u32,
		   int64_t	i64, uint64_t	u64,
		   float32_t	f32, float64_t	f64,
		   v)
{
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v, v
    };
    if (i8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, i8,  t.i8);
    if (u8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, u8,  t.u8);
    if (i16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, i16, t.i16);
    if (u16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, u16, t.u16);
    if (i32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, i32, t.i32);
    if (u32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, u32, t.u32);
    if (i64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, i64, t.i64);
    if (u64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, u64, t.u64);
    if (f32 != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, f32, t.f32);
    if (f64 != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, f64, t.f64);
    if (v   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, v,   t.v);
}
void t36_call_test_args(v) {
    t36_test_args(v, v,
		  v, v,
		  v, v,
		  v, v,
		  v, v,
		  v);
}
void t36_test_locs(v)
{
    int8_t	i8;	uint8_t		u8;
    int16_t	i16;	uint16_t	u16;
    int32_t	i32;	uint32_t	u32;
    int64_t	i64;	uint64_t	u64;
    float32_t	f32;	float64_t	f64;
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v, v
    };
    auto again = true;
    i8  = v;	u8  = v;
    i16 = v;	u16 = v;
    i32 = v;	u32 = v;
    i64 = v;	u64 = v;
    f32 = v;	f64 = v;
repeat:
    if (i8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, i8,  t.i8);
    if (u8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, u8,  t.u8);
    if (i16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, i16, t.i16);
    if (u16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, u16, t.u16);
    if (i32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, i32, t.i32);
    if (u32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, u32, t.u32);
    if (i64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, i64, t.i64);
    if (u64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, u64, t.u64);
    if (f32 != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, f32, t.f32);
    if (f64 != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, f64, t.f64);
    if (v   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, v,   t.v);
    if (again) {
	again = false;
	i8 = u8 = i16 = u16 = i32 = u32 = i64 = u64 = f32 = f64 = v;
	goto repeat;
    }
}
/* FIXME casting operator should be implemented (and union extended) */
int8_t t36_i8_v(v) {
    int8_t	i8 = v;
    return i8;
}
uint8_t t36_u8_v(v) {
    uint8_t	u8 = v;
    return u8;
}
int16_t t36_i16_v(v) {
    int16_t	i16 = v;
    return i16;
}
uint16_t t36_u16_v(v) {
    uint16_t	u16 = v;
    return u16;
}
int32_t t36_i32_v(v) {
    int32_t	i32 = v;
    return i32;
}
uint32_t t36_u32_v(v) {
    uint32_t	u32 = v;
    return u32;
}
int64_t t36_i64_v(v) {
    int64_t	i64 = v;
    return i64;
}
uint64_t t36_u64_v(v) {
    uint64_t	u64 = v;
    return u64;
}
float32_t t36_f32_v(v) {
    float32_t	f32 = v;
    return f32;
}
float64_t t36_f64_v(v) {
    float64_t	f64 = v;
    return f64;
}
void t36_test_rets(v)
{
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v
    };
    auto r;
    if ((r = t36_i8_v(v))  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, r, t.i8);
    if ((r = t36_u8_v(v))  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, r, t.u8);
    if ((r = t36_i16_v(v)) != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, r, t.i16);
    if ((r = t36_u16_v(v)) != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, r, t.u16);
    if ((r = t36_i32_v(v)) != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, r, t.i32);
    if ((r = t36_u32_v(v)) != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, r, t.u32);
    if ((r = t36_i64_v(v)) != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, r, t.i64);
    if ((r = t36_u64_v(v)) != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, r, t.u64);
    if ((r = t36_f32_v(v)) != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, r, t.f32);
    if ((r = t36_f64_v(v)) != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, r, t.f64);
}
#define t36_def_test_prop(value, ident)					\
auto t36_test_prop_##ident() {						\
    int8_t	i8  = value;	uint8_t		u8  = value;		\
    int16_t	i16 = value;	uint16_t	u16 = value;		\
    int32_t	i32 = value;	uint32_t	u32 = value;		\
    int64_t	i64 = value;	uint64_t	u64 = value;		\
    float32_t	f32 = value;	float64_t	f64 = value;		\
    auto	v   = value;						\
    t36_t t = {								\
	v, v, v, v, v, v, v, v, v, v, v					\
    };									\
    auto again = true;							\
repeat:									\
    if (i8  != t.i8)							\
	print("error %d: i8  %#d %d %d\n", __LINE__, v, i8,  t.i8);	\
    if (u8  != t.u8)							\
	print("error %d: u8  %#d %d %d\n", __LINE__, v, u8,  t.u8);	\
    if (i16 != t.i16)							\
	print("error %d: i16 %#d %d %d\n", __LINE__, v, i16, t.i16);	\
    if (u16 != t.u16)							\
	print("error %d: u16 %#d %d %d\n", __LINE__, v, u16, t.u16);	\
    if (i32 != t.i32)							\
	print("error %d: i32 %#d %d %d\n", __LINE__, v, i32, t.i32);	\
    if (u32 != t.u32)							\
	print("error %d: u32 %#d %d %d\n", __LINE__, v, u32, t.u32);	\
    if (i64 != t.i64)							\
	print("error %d: i64 %#d %d %d\n", __LINE__, v, i64, t.i64);	\
    if (u64 != t.u64)							\
	print("error %d: u64 %#d %d %d\n", __LINE__, v, u64, t.u64);	\
    if (f32 != t.f32)							\
	print("error %d: f32 %#d %d %d\n", __LINE__, v, f32, t.f32);	\
    if (f64 != t.f64)							\
	print("error %d: f64 %#d %d %d\n", __LINE__, v, f64, t.f64);	\
    if (v   != t.v)							\
	print("error %d: v   %#d %d %d\n", __LINE__, v, v,   t.v);	\
    if (again) {							\
	again = false;							\
	i8 = u8 = i16 = u16 = i32 = u32 = i64 = u64 =			\
	    f32 = f64 = v = value;					\
	goto repeat;							\
    }									\
}
#define t36_call_test_prop(ident)	t36_test_prop_##ident()
t36_def_test_prop(0,				0);
t36_def_test_prop(-0x7f,			1);
t36_def_test_prop(-0x7fff,			2);
t36_def_test_prop(-0x7fffffff,			3);
t36_def_test_prop(-0x7fffffffffffffff,		4);
t36_def_test_prop(0x7f,				5);
t36_def_test_prop(0x7fff,			6);
t36_def_test_prop(0x7fffffff,			7);
t36_def_test_prop(0x7fffffffffffffff,		8);
t36_def_test_prop(-0x80,			9);
t36_def_test_prop(-0x8000,			10);
t36_def_test_prop(-0x80000000,			11);
t36_def_test_prop(-0x8000000000000000,		12);
t36_def_test_prop(0x80,				13);
t36_def_test_prop(0x8000,			14);
t36_def_test_prop(0x80000000,			15);
t36_def_test_prop(0x8000000000000000,		16);
t36_def_test_prop(-0xff,			17);
t36_def_test_prop(-0xffff,			18);
t36_def_test_prop(-0xffffffff,			19);
t36_def_test_prop(-0xffffffffffffffff,		20);
t36_def_test_prop(0xff,				21);
t36_def_test_prop(0xffff,			22);
t36_def_test_prop(0xffffffff,			23);
t36_def_test_prop(0xffffffffffffffff,		24);
t36_def_test_prop(0.0,				25);
t36_def_test_prop(-0x7f.0,			26);
t36_def_test_prop(-0x7fff.0,			27);
t36_def_test_prop(-0x7fffffff.0,		28);
t36_def_test_prop(-0x7fffffffffffffff.0,	29);
t36_def_test_prop(0x7f.0,			30);
t36_def_test_prop(0x7fff.0,			31);
t36_def_test_prop(0x7fffffff.0,			32);
t36_def_test_prop(0x7fffffffffffffff.0,		33);
t36_def_test_prop(-0x80.0,			34);
t36_def_test_prop(-0x8000.0,			35);
t36_def_test_prop(-0x80000000.0,		36);
t36_def_test_prop(-0x8000000000000000.0,	37);
t36_def_test_prop(0x80.0,			38);
t36_def_test_prop(0x8000.0,			39);
t36_def_test_prop(0x80000000.0,			40);
t36_def_test_prop(0x8000000000000000.0,		41);
t36_def_test_prop(-0xff.0,			42);
t36_def_test_prop(-0xffff.0,			43);
t36_def_test_prop(-0xffffffff.0,		44);
t36_def_test_prop(-0xffffffffffffffff.0,	45);
t36_def_test_prop(0xff.0,			46);
t36_def_test_prop(0xffff.0,			47);
t36_def_test_prop(0xffffffff.0,			48);
t36_def_test_prop(0xffffffffffffffff.0,		49);
t36_def_test_prop(-0x17e/3,			50);
t36_def_test_prop(-0x17ffe/3,			51);
t36_def_test_prop(-0x17ffffffe/3,		52);
t36_def_test_prop(-0x17ffffffffffffffe/3,	53);
t36_def_test_prop(0x17e/3,			54);
t36_def_test_prop(0x17ffe/3,			55);
t36_def_test_prop(0x17ffffffe/3,		56);
t36_def_test_prop(0x17ffffffffffffffe/3,	57);
t36_def_test_prop(-0x181/3,			58);
t36_def_test_prop(-0x18001/3,			59);
t36_def_test_prop(-0x180000001/3,		60);
t36_def_test_prop(-0x18000000000000001/3,	61);
t36_def_test_prop(0x181/3,			62);
t36_def_test_prop(0x18001/3,			63);
t36_def_test_prop(0x180000001/3,		64);
t36_def_test_prop(0x18000000000000001/3,	65);
t36_def_test_prop(-0x2fe/3,			66);
t36_def_test_prop(-0x2fffe/3,			67);
t36_def_test_prop(-0x2fffffffe/3,		68);
t36_def_test_prop(-0x2fffffffffffffffe/3,	69);
t36_def_test_prop(0x2fe/3,			70);
t36_def_test_prop(0x2fffe/3,			71);
t36_def_test_prop(0x2fffffffe/3,		72);
t36_def_test_prop(0x2fffffffffffffffe/3,	73);
t36_def_test_prop(0L,				74);
t36_def_test_prop(-0x7fL,			75);
t36_def_test_prop(-0x7fffL,			76);
t36_def_test_prop(-0x7fffffffL,			77);
t36_def_test_prop(-0x7fffffffffffffffL,		78);
t36_def_test_prop(0x7fL,			79);
t36_def_test_prop(0x7fffL,			80);
t36_def_test_prop(0x7fffffffL,			81);
t36_def_test_prop(0x7fffffffffffffffL,		82);
t36_def_test_prop(-0x80L,			83);
t36_def_test_prop(-0x8000L,			84);
t36_def_test_prop(-0x80000000L,			85);
t36_def_test_prop(-0x8000000000000000L,		86);
t36_def_test_prop(0x80L,			87);
t36_def_test_prop(0x8000L,			88);
t36_def_test_prop(0x80000000L,			89);
t36_def_test_prop(0x8000000000000000L,		90);
t36_def_test_prop(-0xffL,			91);
t36_def_test_prop(-0xffffL,			92);
t36_def_test_prop(-0xffffffffL,			93);
t36_def_test_prop(-0xffffffffffffffffL,		94);
t36_def_test_prop(0xffL,			95);
t36_def_test_prop(0xffffL,			96);
t36_def_test_prop(0xffffffffL,			97);
t36_def_test_prop(0xffffffffffffffffL,		98);
t36_def_test_prop(0.0+I,			99);
t36_def_test_prop(-1.5+I,			100);
t36_def_test_prop(1.5+I,			101);
t36_def_test_prop(I,				102);
t36_def_test_prop(-3/2+I,			103);
t36_def_test_prop(3/2+I,			104);
t36_def_test_prop(0.0L+I,			105);
t36_def_test_prop(-1.5L+I,			106);
t36_def_test_prop(1.5L+I,			107);
void t36_test_locptrs(v) {
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v, v
    };
    int8_t	 i8;	uint8_t		 u8;
    int16_t	 i16;	uint16_t	 u16;
    int32_t	 i32;	uint32_t	 u32;
    int64_t	 i64;	uint64_t	 u64;
    float32_t	 f32;	float64_t	 f64;
    int8_t	*pi8;	uint8_t		*pu8;
    int16_t	*pi16;	uint16_t	*pu16;
    int32_t	*pi32;	uint32_t	*pu32;
    int64_t	*pi64;	uint64_t	*pu64;
    float32_t	*pf32;	float64_t	*pf64;
    auto	*pv;
    auto	 again = true;
    pi8  = &i8;		pu8  = &u8;
    pi16 = &i16;	pu16 = &u16;
    pi32 = &i32;	pu32 = &u32;
    pi64 = &i64;	pu64 = &u64;
    pf32 = &f32;	pf64 = &f64;
    pv   = &v;
    *pi8  = v;		*pu8  = v;
    *pi16 = v;		*pu16 = v;
    *pi32 = v;		*pu32 = v;
    *pi64 = v;		*pu64 = v;
    *pf32 = v;		*pf64 = v;
repeat:
    if (*pi8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, *pi8,  t.i8);
    if (*pu8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, *pu8,  t.u8);
    if (*pi16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, *pi16, t.i16);
    if (*pu16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, *pu16, t.u16);
    if (*pi32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, *pi32, t.i32);
    if (*pu32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, *pu32, t.u32);
    if (*pi64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, *pi64, t.i64);
    if (*pu64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, *pu64, t.u64);
    if (*pf32 != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, *pf32, t.f32);
    if (*pf64 != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, *pf64, t.f64);
    if (*pv   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, *pv,   t.v);
    if (again) {
	again = false;
	*pi8 = *pu8 = *pi16 = *pu16 = *pi32 = *pu32 =
	    *pi64 = *pu64 = *pf32 = *pf64 = *pv = v;
	goto repeat;
    }
}
void t36_test_globs(v) {
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v, v
    };
    auto again = true;
    t36_i8  = v;		t36_u8  = v;
    t36_i16 = v;		t36_u16 = v;
    t36_i32 = v;		t36_u32 = v;
    t36_i64 = v;		t36_u64 = v;
    t36_f32 = v;		t36_f64 = v;
    t36_v   = v;
repeat:
    if (t36_i8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, t36_i8,  t.i8);
    if (t36_u8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, t36_u8,  t.u8);
    if (t36_i16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, t36_i16, t.i16);
    if (t36_u16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, t36_u16, t.u16);
    if (t36_i32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, t36_i32, t.i32);
    if (t36_u32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, t36_u32, t.u32);
    if (t36_i64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, t36_i64, t.i64);
    if (t36_u64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, t36_u64, t.u64);
    if (t36_f32 != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, t36_f32, t.f32);
    if (t36_f64 != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, t36_f64, t.f64);
    if (t36_v   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, t36_v,   t.v);
    if (again) {
	again = false;
	t36_i8 = t36_u8 = t36_i16 = t36_u16 = t36_i32 = t36_u32 =
	    t36_i64 = t36_u64 = t36_f32 = t36_f64 = t36_v = v;
	goto repeat;
    }
}
void t36_test_globptrs(v) {
    t36_t t = {
	v, v, v, v, v, v, v, v, v, v, v
    };
    int8_t	*pi8;	uint8_t		*pu8;
    int16_t	*pi16;	uint16_t	*pu16;
    int32_t	*pi32;	uint32_t	*pu32;
    int64_t	*pi64;	uint64_t	*pu64;
    float32_t	*pf32;	float64_t	*pf64;
    auto	*pv;
    auto	 again = true;
    pi8  = &t36_i8;	pu8 = &t36_u8;
    pi16 = &t36_i16;	pu16 = &t36_u16;
    pi32 = &t36_i32;	pu32 = &t36_u32;
    pi64 = &t36_i64;	pu64 = &t36_u64;
    pf32 = &t36_f32;	pf64 = &t36_f64;
    pv   = &t36_v;
    *pi8  = v;		*pu8  = v;
    *pi16 = v;		*pu16 = v;
    *pi32 = v;		*pu32 = v;
    *pi64 = v;		*pu64 = v;
    *pf32 = v;		*pf64 = v;
    *pv   = v;
repeat:
    if (*pi8  != t.i8)
	print("error %d: i8  %#d %d %d\n", __LINE__, v, *pi8,  t.i8);
    if (*pu8  != t.u8)
	print("error %d: u8  %#d %d %d\n", __LINE__, v, *pu8,  t.u8);
    if (*pi16 != t.i16)
	print("error %d: i16 %#d %d %d\n", __LINE__, v, *pi16, t.i16);
    if (*pu16 != t.u16)
	print("error %d: u16 %#d %d %d\n", __LINE__, v, *pu16, t.u16);
    if (*pi32 != t.i32)
	print("error %d: i32 %#d %d %d\n", __LINE__, v, *pi32, t.i32);
    if (*pu32 != t.u32)
	print("error %d: u32 %#d %d %d\n", __LINE__, v, *pu32, t.u32);
    if (*pi64 != t.i64)
	print("error %d: i64 %#d %d %d\n", __LINE__, v, *pi64, t.i64);
    if (*pu64 != t.u64)
	print("error %d: u64 %#d %d %d\n", __LINE__, v, *pu64, t.u64);
    if (*pf32 != t.f32)
	print("error %d: f32 %#d %d %d\n", __LINE__, v, *pf32, t.f32);
    if (*pf64 != t.f64)
	print("error %d: f64 %#d %d %d\n", __LINE__, v, *pf64, t.f64);
    if (*pv   != t.v)
	print("error %d: v   %#d %d %d\n", __LINE__, v, *pv,   t.v);
    if (again) {
	again = false;
	*pi8 = *pu8 = *pi16 = *pu16 = *pi32 = *pu32 =
	    *pi64 = *pu64 = *pf32 = *pf64 = *pv = v;
	goto repeat;
    }
}
t36_test(-0xffffffffffffffff,
	  0x0000000000000001 &	     0xff,
	  0x0000000000000001 &	     0xff,
	  0x0000000000000001 &	   0xffff,
	  0x0000000000000001 &	   0xffff,
	  0x0000000000000001 & 0xffffffff,
	  0x0000000000000001 & 0xffffffff,
	  0x0000000000000001,
	  0x0000000000000001,
	 -0xffffffffffffffff.0,
	 -0xffffffffffffffff.0, 1);
t36_test(-0x8000000000000001,
	 (0x7fffffffffffffff &	     0xff) -		   0x100,
	  0x7fffffffffffffff &	     0xff,
	 (0x7fffffffffffffff &	   0xffff) -		 0x10000,
	  0x7fffffffffffffff &	   0xffff,
	 (0x7fffffffffffffff & 0xffffffff) -	     0x100000000,
	  0x7fffffffffffffff & 0xffffffff,
	  0x7fffffffffffffff		   - 0x10000000000000000,
	  0x7fffffffffffffff,
	 -0x8000000000000000.0,
	 -0x8000000000000000.0, 1);
t36_test(-0x8000000000000000,
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	 -0x8000000000000000.0,
	 -0x8000000000000000.0, 1);
t36_test(-0x7fffffffffffffff,
	 (0x8000000000000001 &	     0xff) -		   0x100,
	  0x8000000000000001 &	     0xff,
	 (0x8000000000000001 &	   0xffff) -		 0x10000,
	  0x8000000000000001 &	   0xffff,
	 (0x8000000000000001 & 0xffffffff) -	     0x100000000,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001		   - 0x10000000000000000,
	  0x8000000000000001,
	 -0x7fffffffffffffff.0,
	 -0x7fffffffffffffff.0, 1);
t36_test(	 -0xffffffff,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001		   - 0x10000000000000000,
	  0xffffffff00000001,
		 -0xffffffff.0,
		 -0xffffffff.0, 1);
t36_test(	 -0x80000001,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff		   -	     0x100000000,
		  0x7fffffff,
	  0xffffffff7fffffff		   - 0x10000000000000000,
	  0xffffffff7fffffff,
		 -0x80000001.0,
		 -0x80000001.0, 1);
t36_test(	 -0x80000000,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 &	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0xffffffff80000000		   - 0x10000000000000000,
	  0xffffffff80000000,
		 -0x80000000.0,
		 -0x80000000.0, 1);
t36_test(	 -0x7fffffff,
		 (0x80000001 &	     0xff) -		   0x100,
		  0x80000001 &	     0xff,
		 (0x80000001 &	   0xffff) -		 0x10000,
		  0x80000001 &	   0xffff,
		  0x80000001		   -	     0x100000000,
		  0x80000001,
	  0xffffffff80000001		   - 0x10000000000000000,
	  0xffffffff80000001,
		 -0x7fffffff.0,
		 -0x7fffffff.0, 1);
t36_test(	     -0xffff,
	         (0xffff0001 &	     0xff) -		   0x100,
		  0xffff0001 &	     0xff,
	         (0xffff0001 &	   0xffff) -		 0x10000,
		  0xffff0001 &	   0xffff,
		  0xffff0001		   -	     0x100000000,
		  0xffff0001,
	  0xffffffffffff0001		   - 0x10000000000000000,
	  0xffffffffffff0001,
		   -0xffff.0,
		   -0xffff.0, 1);
t36_test(	     -0x8001,
		     (0x7fff & 0xff)	   -		   0x100,
		      0x7fff & 0xff,
		      0x7fff		   -	         0x10000,
		      0x7fff,
		  0xffff7fff		   -	     0x100000000,
		  0xffff7fff,
	  0xffffffffffff7fff		   - 0x10000000000000000,
	  0xffffffffffff7fff,
		     -0x8001.0,
		     -0x8001.0, 1);
t36_test(	     -0x8000,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0xffff8000		   -	     0x100000000,
		  0xffff8000,
	  0xffffffffffff8000		   - 0x10000000000000000,
	  0xffffffffffff8000,
		     -0x8000.0,
		     -0x8000.0, 1);
t36_test(	     -0x7fff,
		     (0x8001 & 0xff)	   -		   0x100,
		      0x8001 & 0xff,
		      0x8001		   -	         0x10000,
		      0x8001,
		  0xffff8001		   -	     0x100000000,
		  0xffff8001,
	  0xffffffffffff8001		   - 0x10000000000000000,
	  0xffffffffffff8001,
		     -0x7fff.0,
		     -0x7fff.0, 1);
t36_test(	       -0xff,
		     (0xff01 &	     0xff) -		   0x100,
		      0xff01 &	     0xff,
		      0xff01		   -		 0x10000,
		      0xff01,
		  0xffffff01		   -	     0x100000000,
		  0xffffff01,
	  0xffffffffffffff01		   - 0x10000000000000000,
	  0xffffffffffffff01,
		       -0xff.0,
		       -0xff.0, 1);
t36_test(	       -0x81,
	 		0x7f		   -		   0x100,
			0x7f,
		      0xff7f		   -		 0x10000,
		      0xff7f,
		  0xffffff7f		   -	     0x100000000,
		  0xffffff7f,
	  0xffffffffffffff7f		   - 0x10000000000000000,
	  0xffffffffffffff7f,
		       -0x81.0,
		       -0x81.0, 1);
t36_test(	       -0x80,
			0x80		   -		   0x100,
			0x80,
		      0xff80		   -		 0x10000,
		      0xff80,
		  0xffffff80		   -	     0x100000000,
		  0xffffff80,
	  0xffffffffffffff80		   - 0x10000000000000000,
	  0xffffffffffffff80,
		       -0x80.0,
		       -0x80.0, 1);
t36_test(	       -0x7f,
	 		0x81		   -		   0x100,
			0x81,
		      0xff81		   -		 0x10000,
		      0xff81,
		  0xffffff81		   -	     0x100000000,
		  0xffffff81,
	  0xffffffffffffff81		   - 0x10000000000000000,
	  0xffffffffffffff81,
		       -0x7f.0,
		       -0x7f.0, 1);
t36_test(		0x00,
	 		0x00,
		 	0x00,
		      0x0000,
		      0x0000,
		  0x00000000,
		  0x00000000,
	  0x0000000000000000,
	  0x0000000000000000,
		           0.0,
			   0.0, 1);
t36_test(		0x7f,
			0x7f,
			0x7f,
		      0x007f,
		      0x007f,
		  0x0000007f,
	 	  0x0000007f,
	  0x000000000000007f,
	  0x000000000000007f,
			0x7f.0,
			0x7f.0, 1);
t36_test(	        0x80,
		        0x80		   -		   0x100,
		        0x80,
		      0x0080,
		      0x0080,
		  0x00000080,
		  0x00000080,
	  0x0000000000000080,
	  0x0000000000000080,
		        0x80.0,
		        0x80.0, 1);
t36_test(		0x81,
			0x81		   -		   0x100,
			0x81,
		      0x0081,
		      0x0081,
		  0x00000081,
	 	  0x00000081,
	  0x0000000000000081,
	  0x0000000000000081,
			0x81.0,
			0x81.0, 1);
t36_test(		0xff,
			0xff - 0x100,
			0xff,
		      0x00ff,
		      0x00ff,
		  0x000000ff,
		  0x000000ff,
	  0x00000000000000ff,
	  0x00000000000000ff,
			0xff.0,
			0xff.0, 1);
t36_test(	      0x7fff,
		     (0x7fff &	     0xff) -		   0x100,
		      0x7fff &	     0xff,
		      0x7fff,
		      0x7fff,
		  0x00007fff,
		  0x00007fff,
	  0x0000000000007fff,
	  0x0000000000007fff,
		      0x7fff.0,
		      0x7fff.0, 1);
t36_test(	      0x8000,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0x00008000,
		  0x00008000,
	  0x0000000000008000,
	  0x0000000000008000,
		      0x8000.0,
		      0x8000.0, 1);
t36_test(	      0x8001,
		      0x8001 &	     0xff,
		      0x8001 &	     0xff,
		      0x8001,
		      0x8001,
		  0x00008001,
		  0x00008001,
	  0x0000000000008001,
	  0x0000000000008001,
		      0x8001.0,
		      0x8001.0, 1);
t36_test(	      0xffff,
		     (0xffff &	     0xff) -		   0x100,
		      0xffff &	     0xff,
		      0xffff		   -		 0x10000,
		      0xffff,
		  0x0000ffff,
		  0x0000ffff,
	  0x000000000000ffff,
	  0x000000000000ffff,
		      0xffff.0,
		      0xffff.0, 1);
t36_test(	  0x7fffffff,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff,
		  0x7fffffff,
	  0x000000007fffffff,
	  0x000000007fffffff,
		  0x7fffffff.0,
		  0x7fffffff.0, 1);
t36_test(	  0x80000000,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 & 	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0x0000000080000000,
	  0x0000000080000000,
		  0x80000000.0,
		  0x80000000.0, 1);
t36_test(	  0x80000001,
		  0x80000001 &	     0xff,
		  0x80000001 &	     0xff,
		  0x80000001 &	   0xffff,
		  0x80000001 &	   0xffff,
		  0x80000001,
		  0x80000001,
	  0x0000000080000001,
	  0x0000000080000001,
		  0x80000001.0,
		  0x80000001.0, 1);
t36_test(	  0xffffffff,
		 (0xffffffff &	     0xff) -		   0x100,
		  0xffffffff &	     0xff,
		 (0xffffffff &	   0xffff) -		 0x10000,
		  0xffffffff &	   0xffff,
		  0xffffffff		   -	     0x100000000,
		  0xffffffff,
	  0x00000000ffffffff,
	  0x00000000ffffffff,
		  0xffffffff.0,
		  0xffffffff.0, 1);
t36_test( 0x7fffffffffffffff,
	 (0x7fffffffffffffff &	     0xff) -		   0x100,
	  0x7fffffffffffffff &	     0xff,
	 (0x7fffffffffffffff &	   0xffff) -		 0x10000,
	  0x7fffffffffffffff &	   0xffff,
	 (0x7fffffffffffffff & 0xffffffff) -	     0x100000000,
	  0x7fffffffffffffff & 0xffffffff,
	  0x7fffffffffffffff,
	  0x7fffffffffffffff,
	  0x7fffffffffffffff.0,
	  0x7fffffffffffffff.0, 1);
t36_test( 0x8000000000000000,
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	  0x8000000000000000.0,
	  0x8000000000000000.0, 1);
t36_test( 0x8000000000000001,
	  0x8000000000000001 &	     0xff,
	  0x8000000000000001 &	     0xff,
	  0x8000000000000001 &	   0xffff,
	  0x8000000000000001 &	   0xffff,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001		   - 0x10000000000000000,
	  0x8000000000000001,
	  0x8000000000000001.0,
	  0x8000000000000001.0, 1);
t36_test( 0xffffffffffffffff,
	 (0xffffffffffffffff &	     0xff) -		   0x100,
	  0xffffffffffffffff &	     0xff,
	 (0xffffffffffffffff &	   0xffff) -		 0x10000,
	  0xffffffffffffffff &	   0xffff,
	 (0xffffffffffffffff & 0xffffffff) -	     0x100000000,
	  0xffffffffffffffff & 0xffffffff,
	  0xffffffffffffffff		   - 0x10000000000000000,
	  0xffffffffffffffff,
	  0xffffffffffffffff.0,
	  0xffffffffffffffff.0, 1);
t36_test(	 -0x80000000.0,		/* FIXME only "sensible values" - maybe implement a some mpz_get_d() that matches mpz_set_d() */
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 &	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0xffffffff80000000		   - 0x10000000000000000,
	  0xffffffff80000000,
		 -0x80000000.0,
		 -0x80000000.0, 0);
t36_test(	     -0x8000.0,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0xffff8000		   -	     0x100000000,
		  0xffff8000,
	  0xffffffffffff8000		   - 0x10000000000000000,
	  0xffffffffffff8000,
		     -0x8000.0,
		     -0x8000.0, 0);
t36_test(	       -0x80.0,
			0x80		   -		   0x100,
			0x80,
		      0xff80		   -		 0x10000,
		      0xff80,
		  0xffffff80		   -	     0x100000000,
		  0xffffff80,
	  0xffffffffffffff80		   - 0x10000000000000000,
	  0xffffffffffffff80,
		       -0x80.0,
		       -0x80.0, 0);
t36_test(	       -0x7f,
	 		0x81		   -		   0x100,
			0x81,
		      0xff81		   -		 0x10000,
		      0xff81,
		  0xffffff81		   -	     0x100000000,
		  0xffffff81,
	  0xffffffffffffff81		   - 0x10000000000000000,
	  0xffffffffffffff81,
		       -0x7f.0,
		       -0x7f.0, 0);
t36_test(		0x00.0,
	 		0x00,
		 	0x00,
		      0x0000,
		      0x0000,
		  0x00000000,
		  0x00000000,
	  0x0000000000000000,
	  0x0000000000000000,
		           0.0,
			   0.0, 0);
t36_test(	        0x80.0,
		        0x80		   -		   0x100,
		        0x80,
		      0x0080,
		      0x0080,
		  0x00000080,
		  0x00000080,
	  0x0000000000000080,
	  0x0000000000000080,
		        0x80.0,
		        0x80.0, 0);
t36_test(	      0x8000.0,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0x00008000,
		  0x00008000,
	  0x0000000000008000,
	  0x0000000000008000,
		      0x8000.0,
		      0x8000.0, 0);
#if 0		/* mips rounds down to 0x7fffffff */
t36_test(	  0x80000000.0,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 & 	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0x0000000080000000,
	  0x0000000080000000,
		  0x80000000.0,
		  0x80000000.0, 0);
#endif
t36_test(-0x2fffffffffffffffd/3,
	  0x0000000000000001 &	     0xff,
	  0x0000000000000001 &	     0xff,
	  0x0000000000000001 &	   0xffff,
	  0x0000000000000001 &	   0xffff,
	  0x0000000000000001 & 0xffffffff,
	  0x0000000000000001 & 0xffffffff,
	  0x0000000000000001,
	  0x0000000000000001,
	 -0x2fffffffffffffffd/3*1.0,
	 -0x2fffffffffffffffd/3*1.0, 1);
t36_test(-0x18000000000000004/3,
	 (0x7fffffffffffffff &	     0xff) -		   0x100,
	  0x7fffffffffffffff &	     0xff,
	 (0x7fffffffffffffff &	   0xffff) -		 0x10000,
	  0x7fffffffffffffff &	   0xffff,
	 (0x7fffffffffffffff & 0xffffffff) -	     0x100000000,
	  0x7fffffffffffffff & 0xffffffff,
	  0x7fffffffffffffff		   - 0x10000000000000000,
	  0x7fffffffffffffff,
	 -0x18000000000000004/3*1.0,
	 -0x18000000000000004/3*1.0, 1);
t36_test(-0x18000000000000001/3,
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	 -0x18000000000000001/3*1.0,
	 -0x18000000000000001/3*1.0, 1);
t36_test(-0x17ffffffffffffffd/3,
	 (0x8000000000000001 &	     0xff) -		   0x100,
	  0x8000000000000001 &	     0xff,
	 (0x8000000000000001 &	   0xffff) -		 0x10000,
	  0x8000000000000001 &	   0xffff,
	 (0x8000000000000001 & 0xffffffff) -	     0x100000000,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001		   - 0x10000000000000000,
	  0x8000000000000001,
	 -0x17ffffffffffffffd/3*1.0,
	 -0x17ffffffffffffffd/3*1.0, 1);
t36_test(	 -0x2fffffffe/3,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001		   - 0x10000000000000000,
	  0xffffffff00000001,
		 -0x2fffffffe/3*1.0,
		 -0x2fffffffe/3*1.0, 1);
t36_test(	 -0x180000004/3,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff		   -	     0x100000000,
		  0x7fffffff,
	  0xffffffff7fffffff		   - 0x10000000000000000,
	  0xffffffff7fffffff,
		 -0x180000004/3*1.0,
		 -0x180000004/3*1.0, 1);
t36_test(	 -0x180000001/3,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 &	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0xffffffff80000000		   - 0x10000000000000000,
	  0xffffffff80000000,
		 -0x180000001/3*1.0,
		 -0x180000001/3*1.0, 1);
t36_test(	 -0x17ffffffe/3,
		 (0x80000001 &	     0xff) -		   0x100,
		  0x80000001 &	     0xff,
		 (0x80000001 &	   0xffff) -		 0x10000,
		  0x80000001 &	   0xffff,
		  0x80000001		   -	     0x100000000,
		  0x80000001,
	  0xffffffff80000001		   - 0x10000000000000000,
	  0xffffffff80000001,
		 -0x17ffffffe/3*1.0,
		 -0x17ffffffe/3*1.0, 1);
t36_test(	     -0x2fffe/3,
	         (0xffff0001 &	     0xff) -		   0x100,
		  0xffff0001 &	     0xff,
	         (0xffff0001 &	   0xffff) -		 0x10000,
		  0xffff0001 &	   0xffff,
		  0xffff0001		   -	     0x100000000,
		  0xffff0001,
	  0xffffffffffff0001		   - 0x10000000000000000,
	  0xffffffffffff0001,
		    -0x2fffe/3*1.0,
		    -0x2fffe/3*1.0, 1);
t36_test(	     -0x18004/3,
		     (0x7fff & 0xff)	   -		   0x100,
		      0x7fff & 0xff,
		      0x7fff		   -	         0x10000,
		      0x7fff,
		  0xffff7fff		   -	     0x100000000,
		  0xffff7fff,
	  0xffffffffffff7fff		   - 0x10000000000000000,
	  0xffffffffffff7fff,
		     -0x18004/3*1.0,
		     -0x18004/3*1.0, 1);
t36_test(	     -0x18001/3,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0xffff8000		   -	     0x100000000,
		  0xffff8000,
	  0xffffffffffff8000		   - 0x10000000000000000,
	  0xffffffffffff8000,
		     -0x18001/3*1.0,
		     -0x18001/3*1.0, 1);
t36_test(	     -0x17ffe/3,
		     (0x8001 & 0xff)	   -		   0x100,
		      0x8001 & 0xff,
		      0x8001		   -	         0x10000,
		      0x8001,
		  0xffff8001		   -	     0x100000000,
		  0xffff8001,
	  0xffffffffffff8001		   - 0x10000000000000000,
	  0xffffffffffff8001,
		     -0x17ffe/3*1.0,
		     -0x17ffe/3*1.0, 1);
t36_test(	       -0x2fe/3,
		     (0xff01 &	     0xff) -		   0x100,
		      0xff01 &	     0xff,
		      0xff01		   -		 0x10000,
		      0xff01,
		  0xffffff01		   -	     0x100000000,
		  0xffffff01,
	  0xffffffffffffff01		   - 0x10000000000000000,
	  0xffffffffffffff01,
		       -0x2fe/3*1.0,
		       -0x2fe/3*1.0, 1);
t36_test(	       -0x184/3,
	 		0x7f		   -		   0x100,
			0x7f,
		      0xff7f		   -		 0x10000,
		      0xff7f,
		  0xffffff7f		   -	     0x100000000,
		  0xffffff7f,
	  0xffffffffffffff7f		   - 0x10000000000000000,
	  0xffffffffffffff7f,
		       -0x184/3*1.0,
		       -0x184/3*1.0, 1);
t36_test(	       -0x181/3,
			0x80		   -		   0x100,
			0x80,
		      0xff80		   -		 0x10000,
		      0xff80,
		  0xffffff80		   -	     0x100000000,
		  0xffffff80,
	  0xffffffffffffff80		   - 0x10000000000000000,
	  0xffffffffffffff80,
		       -0x181/3*1.0,
		       -0x181/3*1.0, 1);
t36_test(	       -0x17e/3,
	 		0x81		   -		   0x100,
			0x81,
		      0xff81		   -		 0x10000,
		      0xff81,
		  0xffffff81		   -	     0x100000000,
		  0xffffff81,
	  0xffffffffffffff81		   - 0x10000000000000000,
	  0xffffffffffffff81,
		       -0x17e/3*1.0,
		       -0x17e/3*1.0, 1);
t36_test(		0x17e/3,
			0x7f,
			0x7f,
		      0x007f,
		      0x007f,
		  0x0000007f,
	 	  0x0000007f,
	  0x000000000000007f,
	  0x000000000000007f,
			0x17e/3*1.0,
			0x17e/3*1.0, 1);
t36_test(	        0x181/3,
		        0x80		   -		   0x100,
		        0x80,
		      0x0080,
		      0x0080,
		  0x00000080,
		  0x00000080,
	  0x0000000000000080,
	  0x0000000000000080,
		        0x181/3*1.0,
		        0x181/3*1.0, 1);
t36_test(		0x184/3,
			0x81		   -		   0x100,
			0x81,
		      0x0081,
		      0x0081,
		  0x00000081,
	 	  0x00000081,
	  0x0000000000000081,
	  0x0000000000000081,
			0x184/3*1.0,
			0x184/3*1.0, 1);
t36_test(		0x2fe/3,
			0xff - 0x100,
			0xff,
		      0x00ff,
		      0x00ff,
		  0x000000ff,
		  0x000000ff,
	  0x00000000000000ff,
	  0x00000000000000ff,
			0x2fe/3*1.0,
			0x2fe/3*1.0, 1);
t36_test(	      0x17ffe/3,
		     (0x7fff &	     0xff) -		   0x100,
		      0x7fff &	     0xff,
		      0x7fff,
		      0x7fff,
		  0x00007fff,
		  0x00007fff,
	  0x0000000000007fff,
	  0x0000000000007fff,
		      0x17ffe/3*1.0,
		      0x17ffe/3*1.0, 1);
t36_test(	      0x18001/3,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0x00008000,
		  0x00008000,
	  0x0000000000008000,
	  0x0000000000008000,
		      0x18001/3*1.0,
		      0x18001/3*1.0, 1);
t36_test(	      0x18004/3,
		      0x8001 &	     0xff,
		      0x8001 &	     0xff,
		      0x8001,
		      0x8001,
		  0x00008001,
		  0x00008001,
	  0x0000000000008001,
	  0x0000000000008001,
		      0x18004/3*1.0,
		      0x18004/3*1.0, 1);
t36_test(	      0x2fffe/3,
		     (0xffff &	     0xff) -		   0x100,
		      0xffff &	     0xff,
		      0xffff		   -		 0x10000,
		      0xffff,
		  0x0000ffff,
		  0x0000ffff,
	  0x000000000000ffff,
	  0x000000000000ffff,
		      0x2fffe/3*1.0,
		      0x2fffe/3*1.0, 1);
t36_test(	  0x17ffffffe/3,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff,
		  0x7fffffff,
	  0x000000007fffffff,
	  0x000000007fffffff,
		  0x17ffffffe/3*1.0,
		  0x17ffffffe/3*1.0, 1);
t36_test(	  0x180000001/3,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 & 	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0x0000000080000000,
	  0x0000000080000000,
		  0x180000001/3*1.0,
		  0x180000001/3*1.0, 1);
t36_test(	  0x180000004/3,
		  0x80000001 &	     0xff,
		  0x80000001 &	     0xff,
		  0x80000001 &	   0xffff,
		  0x80000001 &	   0xffff,
		  0x80000001,
		  0x80000001,
	  0x0000000080000001,
	  0x0000000080000001,
		  0x180000004/3*1.0,
		  0x180000004/3*1.0, 1);
t36_test(	  0x2fffffffe/3,
		 (0xffffffff &	     0xff) -		   0x100,
		  0xffffffff &	     0xff,
		 (0xffffffff &	   0xffff) -		 0x10000,
		  0xffffffff &	   0xffff,
		  0xffffffff		   -	     0x100000000,
		  0xffffffff,
	  0x00000000ffffffff,
	  0x00000000ffffffff,
		  0x2fffffffe/3*1.0,
		  0x2fffffffe/3*1.0, 1);
t36_test( 0x17ffffffffffffffe/3,
	 (0x7fffffffffffffff &	     0xff) -		   0x100,
	  0x7fffffffffffffff &	     0xff,
	 (0x7fffffffffffffff &	   0xffff) -		 0x10000,
	  0x7fffffffffffffff &	   0xffff,
	 (0x7fffffffffffffff & 0xffffffff) -	     0x100000000,
	  0x7fffffffffffffff & 0xffffffff,
	  0x7fffffffffffffff,
	  0x7fffffffffffffff,
	  0x17ffffffffffffffe/3*1.0,
	  0x17ffffffffffffffe/3*1.0, 1);
t36_test( 0x18000000000000001/3,
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	  0x18000000000000001/3*1.0,
	  0x18000000000000001/3*1.0, 1);
t36_test( 0x18000000000000004/3,
	  0x8000000000000001 &	     0xff,
	  0x8000000000000001 &	     0xff,
	  0x8000000000000001 &	   0xffff,
	  0x8000000000000001 &	   0xffff,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001 & 0xffffffff,
	  0x8000000000000001		   - 0x10000000000000000,
	  0x8000000000000001,
	  0x18000000000000004/3*1.0,
	  0x18000000000000004/3*1.0, 1);
t36_test( 0x2fffffffffffffffe/3,
	 (0xffffffffffffffff &	     0xff) -		   0x100,
	  0xffffffffffffffff &	     0xff,
	 (0xffffffffffffffff &	   0xffff) -		 0x10000,
	  0xffffffffffffffff &	   0xffff,
	 (0xffffffffffffffff & 0xffffffff) -	     0x100000000,
	  0xffffffffffffffff & 0xffffffff,
	  0xffffffffffffffff		   - 0x10000000000000000,
	  0xffffffffffffffff,
	  0x2fffffffffffffffe/3*1.0,
	  0x2fffffffffffffffe/3*1.0, 1);
t36_test(-0x8000000000000000.0L,	/* dependent on mpfr precision - more "precise" tests only values that fit in 32 bits integers */
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	 -0x8000000000000000.0,
	 -0x8000000000000000.0, 0);
t36_test(	 -0xffffffff.0L,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	     0xff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 &	   0xffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001 & 0xffffffff,
	  0xffffffff00000001		   - 0x10000000000000000,
	  0xffffffff00000001,
		 -0xffffffff.0,
		 -0xffffffff.0, 0);
t36_test(	 -0x80000001.0L,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff		   -	     0x100000000,
		  0x7fffffff,
	  0xffffffff7fffffff		   - 0x10000000000000000,
	  0xffffffff7fffffff,
		 -0x80000001.0,
		 -0x80000001.0, 0);
t36_test(	 -0x80000000.0L,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 &	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0xffffffff80000000		   - 0x10000000000000000,
	  0xffffffff80000000,
		 -0x80000000.0,
		 -0x80000000.0, 0);
t36_test(	 -0x7fffffff.0L,
		 (0x80000001 &	     0xff) -		   0x100,
		  0x80000001 &	     0xff,
		 (0x80000001 &	   0xffff) -		 0x10000,
		  0x80000001 &	   0xffff,
		  0x80000001		   -	     0x100000000,
		  0x80000001,
	  0xffffffff80000001		   - 0x10000000000000000,
	  0xffffffff80000001,
		 -0x7fffffff.0,
		 -0x7fffffff.0, 0);
t36_test(	     -0xffff.0L,
	         (0xffff0001 &	     0xff) -		   0x100,
		  0xffff0001 &	     0xff,
	         (0xffff0001 &	   0xffff) -		 0x10000,
		  0xffff0001 &	   0xffff,
		  0xffff0001		   -	     0x100000000,
		  0xffff0001,
	  0xffffffffffff0001		   - 0x10000000000000000,
	  0xffffffffffff0001,
		   -0xffff.0,
		   -0xffff.0, 0);
t36_test(	     -0x8001.0L,
		     (0x7fff & 0xff)	   -		   0x100,
		      0x7fff & 0xff,
		      0x7fff		   -	         0x10000,
		      0x7fff,
		  0xffff7fff		   -	     0x100000000,
		  0xffff7fff,
	  0xffffffffffff7fff		   - 0x10000000000000000,
	  0xffffffffffff7fff,
		     -0x8001.0,
		     -0x8001.0, 0);
t36_test(	     -0x8000.0L,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0xffff8000		   -	     0x100000000,
		  0xffff8000,
	  0xffffffffffff8000		   - 0x10000000000000000,
	  0xffffffffffff8000,
		     -0x8000.0,
		     -0x8000.0, 0);
t36_test(	     -0x7fff.0L,
		     (0x8001 & 0xff)	   -		   0x100,
		      0x8001 & 0xff,
		      0x8001		   -	         0x10000,
		      0x8001,
		  0xffff8001		   -	     0x100000000,
		  0xffff8001,
	  0xffffffffffff8001		   - 0x10000000000000000,
	  0xffffffffffff8001,
		     -0x7fff.0,
		     -0x7fff.0, 0);
t36_test(	       -0xff.0L,
		     (0xff01 &	     0xff) -		   0x100,
		      0xff01 &	     0xff,
		      0xff01		   -		 0x10000,
		      0xff01,
		  0xffffff01		   -	     0x100000000,
		  0xffffff01,
	  0xffffffffffffff01		   - 0x10000000000000000,
	  0xffffffffffffff01,
		       -0xff.0,
		       -0xff.0, 0);
t36_test(	       -0x81.0L,
	 		0x7f		   -		   0x100,
			0x7f,
		      0xff7f		   -		 0x10000,
		      0xff7f,
		  0xffffff7f		   -	     0x100000000,
		  0xffffff7f,
	  0xffffffffffffff7f		   - 0x10000000000000000,
	  0xffffffffffffff7f,
		       -0x81.0,
		       -0x81.0, 0);
t36_test(	       -0x80.0L,
			0x80		   -		   0x100,
			0x80,
		      0xff80		   -		 0x10000,
		      0xff80,
		  0xffffff80		   -	     0x100000000,
		  0xffffff80,
	  0xffffffffffffff80		   - 0x10000000000000000,
	  0xffffffffffffff80,
		       -0x80.0,
		       -0x80.0, 0);
t36_test(	       -0x7f.0L,
	 		0x81		   -		   0x100,
			0x81,
		      0xff81		   -		 0x10000,
		      0xff81,
		  0xffffff81		   -	     0x100000000,
		  0xffffff81,
	  0xffffffffffffff81		   - 0x10000000000000000,
	  0xffffffffffffff81,
		       -0x7f.0,
		       -0x7f.0, 0);
t36_test(		0x00.0L,
	 		0x00,
		 	0x00,
		      0x0000,
		      0x0000,
		  0x00000000,
		  0x00000000,
	  0x0000000000000000,
	  0x0000000000000000,
		           0.0,
			   0.0, 0);
t36_test(		0x7f.0L,
			0x7f,
			0x7f,
		      0x007f,
		      0x007f,
		  0x0000007f,
	 	  0x0000007f,
	  0x000000000000007f,
	  0x000000000000007f,
			0x7f.0,
			0x7f.0, 0);
t36_test(	        0x80.0L,
		        0x80		   -		   0x100,
		        0x80,
		      0x0080,
		      0x0080,
		  0x00000080,
		  0x00000080,
	  0x0000000000000080,
	  0x0000000000000080,
		        0x80.0,
		        0x80.0, 0);
t36_test(		0x81.0L,
			0x81		   -		   0x100,
			0x81,
		      0x0081,
		      0x0081,
		  0x00000081,
	 	  0x00000081,
	  0x0000000000000081,
	  0x0000000000000081,
			0x81.0,
			0x81.0, 0);
t36_test(		0xff.0L,
			0xff - 0x100,
			0xff,
		      0x00ff,
		      0x00ff,
		  0x000000ff,
		  0x000000ff,
	  0x00000000000000ff,
	  0x00000000000000ff,
			0xff.0,
			0xff.0, 0);
t36_test(	      0x7fff.0L,
		     (0x7fff &	     0xff) -		   0x100,
		      0x7fff &	     0xff,
		      0x7fff,
		      0x7fff,
		  0x00007fff,
		  0x00007fff,
	  0x0000000000007fff,
	  0x0000000000007fff,
		      0x7fff.0,
		      0x7fff.0, 0);
t36_test(	      0x8000.0L,
		     (0x8000 &	     0xff) -		   0x100,
		      0x8000 &	     0xff,
		      0x8000		   -		 0x10000,
		      0x8000,
		  0x00008000,
		  0x00008000,
	  0x0000000000008000,
	  0x0000000000008000,
		      0x8000.0,
		      0x8000.0, 0);
t36_test(	      0x8001.0L,
		      0x8001 &	     0xff,
		      0x8001 &	     0xff,
		      0x8001,
		      0x8001,
		  0x00008001,
		  0x00008001,
	  0x0000000000008001,
	  0x0000000000008001,
		      0x8001.0,
		      0x8001.0, 0);
t36_test(	      0xffff.0L,
		     (0xffff &	     0xff) -		   0x100,
		      0xffff &	     0xff,
		      0xffff		   -		 0x10000,
		      0xffff,
		  0x0000ffff,
		  0x0000ffff,
	  0x000000000000ffff,
	  0x000000000000ffff,
		      0xffff.0,
		      0xffff.0, 0);
t36_test(	  0x7fffffff.0L,
		 (0x7fffffff &	     0xff) -		   0x100,
		  0x7fffffff &	     0xff,
		 (0x7fffffff &	   0xffff) -		 0x10000,
		  0x7fffffff &	   0xffff,
		  0x7fffffff,
		  0x7fffffff,
	  0x000000007fffffff,
	  0x000000007fffffff,
		  0x7fffffff.0,
		  0x7fffffff.0, 0);
t36_test(	  0x80000000.0L,
		 (0x80000000 &	     0xff) -		   0x100,
		  0x80000000 &	     0xff,
		 (0x80000000 & 	   0xffff) -		 0x10000,
		  0x80000000 &	   0xffff,
		  0x80000000		   -	     0x100000000,
		  0x80000000,
	  0x0000000080000000,
	  0x0000000080000000,
		  0x80000000.0,
		  0x80000000.0, 0);
t36_test(	  0x80000001.0L,
		  0x80000001 &	     0xff,
		  0x80000001 &	     0xff,
		  0x80000001 &	   0xffff,
		  0x80000001 &	   0xffff,
		  0x80000001,
		  0x80000001,
	  0x0000000080000001,
	  0x0000000080000001,
		  0x80000001.0,
		  0x80000001.0, 0);
t36_test(	  0xffffffff.0L,
		 (0xffffffff &	     0xff) -		   0x100,
		  0xffffffff &	     0xff,
		 (0xffffffff &	   0xffff) -		 0x10000,
		  0xffffffff &	   0xffff,
		  0xffffffff		   -	     0x100000000,
		  0xffffffff,
	  0x00000000ffffffff,
	  0x00000000ffffffff,
		  0xffffffff.0,
		  0xffffffff.0, 0);
t36_test( 0x8000000000000000.0L,
	 (0x8000000000000000 &	     0xff) -		   0x100,
	  0x8000000000000000 &	     0xff,
	 (0x8000000000000000 &	   0xffff) -		 0x10000,
	  0x8000000000000000 &	   0xffff,
	 (0x8000000000000000 & 0xffffffff) -	     0x100000000,
	  0x8000000000000000 & 0xffffffff,
	  0x8000000000000000		   - 0x10000000000000000,
	  0x8000000000000000,
	  0x8000000000000000.0,
	  0x8000000000000000.0, 0);
t36_call_test_args(0);
t36_call_test_args(-0x7f);
t36_call_test_args(-0x7fff);
t36_call_test_args(-0x7fffffff);
t36_call_test_args(-0x7fffffffffffffff);
t36_call_test_args(0x7f);
t36_call_test_args(0x7fff);
t36_call_test_args(0x7fffffff);
t36_call_test_args(0x7fffffffffffffff);
t36_call_test_args(-0x80);
t36_call_test_args(-0x8000);
t36_call_test_args(-0x80000000);
t36_call_test_args(-0x8000000000000000);
t36_call_test_args(0x80);
t36_call_test_args(0x8000);
t36_call_test_args(0x80000000);
t36_call_test_args(0x8000000000000000);
t36_call_test_args(-0xff);
t36_call_test_args(-0xffff);
t36_call_test_args(-0xffffffff);
t36_call_test_args(-0xffffffffffffffff);
t36_call_test_args(0xff);
t36_call_test_args(0xffff);
t36_call_test_args(0xffffffff);
t36_call_test_args(0xffffffffffffffff);
t36_call_test_args(0.0);
t36_call_test_args(-0x7f.0);
t36_call_test_args(-0x7fff.0);
t36_call_test_args(-0x7fffffff.0);
t36_call_test_args(-0x7fffffffffffffff.0);
t36_call_test_args(0x7f.0);
t36_call_test_args(0x7fff.0);
t36_call_test_args(0x7fffffff.0);
t36_call_test_args(0x7fffffffffffffff.0);
t36_call_test_args(-0x80.0);
t36_call_test_args(-0x8000.0);
t36_call_test_args(-0x80000000.0);
t36_call_test_args(-0x8000000000000000.0);
t36_call_test_args(0x80.0);
t36_call_test_args(0x8000.0);
t36_call_test_args(0x80000000.0);
t36_call_test_args(0x8000000000000000.0);
t36_call_test_args(-0xff.0);
t36_call_test_args(-0xffff.0);
t36_call_test_args(-0xffffffff.0);
t36_call_test_args(-0xffffffffffffffff.0);
t36_call_test_args(0xff.0);
t36_call_test_args(0xffff.0);
t36_call_test_args(0xffffffff.0);
t36_call_test_args(0xffffffffffffffff.0);
t36_call_test_args(-0x17e/3);
t36_call_test_args(-0x17ffe/3);
t36_call_test_args(-0x17ffffffe/3);
t36_call_test_args(-0x17ffffffffffffffe/3);
t36_call_test_args(0x17e/3);
t36_call_test_args(0x17ffe/3);
t36_call_test_args(0x17ffffffe/3);
t36_call_test_args(0x17ffffffffffffffe/3);
t36_call_test_args(-0x181/3);
t36_call_test_args(-0x18001/3);
t36_call_test_args(-0x180000001/3);
t36_call_test_args(-0x18000000000000001/3);
t36_call_test_args(0x181/3);
t36_call_test_args(0x18001/3);
t36_call_test_args(0x180000001/3);
t36_call_test_args(0x18000000000000001/3);
t36_call_test_args(-0x2fe/3);
t36_call_test_args(-0x2fffe/3);
t36_call_test_args(-0x2fffffffe/3);
t36_call_test_args(-0x2fffffffffffffffe/3);
t36_call_test_args(0x2fe/3);
t36_call_test_args(0x2fffe/3);
t36_call_test_args(0x2fffffffe/3);
t36_call_test_args(0x2fffffffffffffffe/3);
t36_call_test_args(0L);
t36_call_test_args(-0x7fL);
t36_call_test_args(-0x7fffL);
t36_call_test_args(-0x7fffffffL);
t36_call_test_args(-0x7fffffffffffffffL);
t36_call_test_args(0x7fL);
t36_call_test_args(0x7fffL);
t36_call_test_args(0x7fffffffL);
t36_call_test_args(0x7fffffffffffffffL);
t36_call_test_args(-0x80L);
t36_call_test_args(-0x8000L);
t36_call_test_args(-0x80000000L);
t36_call_test_args(-0x8000000000000000L);
t36_call_test_args(0x80L);
t36_call_test_args(0x8000L);
t36_call_test_args(0x80000000L);
t36_call_test_args(0x8000000000000000L);
t36_call_test_args(-0xffL);
t36_call_test_args(-0xffffL);
t36_call_test_args(-0xffffffffL);
t36_call_test_args(-0xffffffffffffffffL);
t36_call_test_args(0xffL);
t36_call_test_args(0xffffL);
t36_call_test_args(0xffffffffL);
t36_call_test_args(0xffffffffffffffffL);
t36_call_test_args(0.0+I);
t36_call_test_args(-1.5+I);
t36_call_test_args(1.5+I);
t36_call_test_args(I);
t36_call_test_args(-3/2+I);
t36_call_test_args(3/2+I);
t36_call_test_args(0.0L+I);
t36_call_test_args(-1.5L+I);
t36_call_test_args(1.5L+I);
t36_test_locs(0);
t36_test_locs(-0x7f);
t36_test_locs(-0x7fff);
t36_test_locs(-0x7fffffff);
t36_test_locs(-0x7fffffffffffffff);
t36_test_locs(0x7f);
t36_test_locs(0x7fff);
t36_test_locs(0x7fffffff);
t36_test_locs(0x7fffffffffffffff);
t36_test_locs(-0x80);
t36_test_locs(-0x8000);
t36_test_locs(-0x80000000);
t36_test_locs(-0x8000000000000000);
t36_test_locs(0x80);
t36_test_locs(0x8000);
t36_test_locs(0x80000000);
t36_test_locs(0x8000000000000000);
t36_test_locs(-0xff);
t36_test_locs(-0xffff);
t36_test_locs(-0xffffffff);
t36_test_locs(-0xffffffffffffffff);
t36_test_locs(0xff);
t36_test_locs(0xffff);
t36_test_locs(0xffffffff);
t36_test_locs(0xffffffffffffffff);
t36_test_locs(0.0);
t36_test_locs(-0x7f.0);
t36_test_locs(-0x7fff.0);
t36_test_locs(-0x7fffffff.0);
t36_test_locs(-0x7fffffffffffffff.0);
t36_test_locs(0x7f.0);
t36_test_locs(0x7fff.0);
t36_test_locs(0x7fffffff.0);
t36_test_locs(0x7fffffffffffffff.0);
t36_test_locs(-0x80.0);
t36_test_locs(-0x8000.0);
t36_test_locs(-0x80000000.0);
t36_test_locs(-0x8000000000000000.0);
t36_test_locs(0x80.0);
t36_test_locs(0x8000.0);
t36_test_locs(0x80000000.0);
t36_test_locs(0x8000000000000000.0);
t36_test_locs(-0xff.0);
t36_test_locs(-0xffff.0);
t36_test_locs(-0xffffffff.0);
t36_test_locs(-0xffffffffffffffff.0);
t36_test_locs(0xff.0);
t36_test_locs(0xffff.0);
t36_test_locs(0xffffffff.0);
t36_test_locs(0xffffffffffffffff.0);
t36_test_locs(-0x17e/3);
t36_test_locs(-0x17ffe/3);
t36_test_locs(-0x17ffffffe/3);
t36_test_locs(-0x17ffffffffffffffe/3);
t36_test_locs(0x17e/3);
t36_test_locs(0x17ffe/3);
t36_test_locs(0x17ffffffe/3);
t36_test_locs(0x17ffffffffffffffe/3);
t36_test_locs(-0x181/3);
t36_test_locs(-0x18001/3);
t36_test_locs(-0x180000001/3);
t36_test_locs(-0x18000000000000001/3);
t36_test_locs(0x181/3);
t36_test_locs(0x18001/3);
t36_test_locs(0x180000001/3);
t36_test_locs(0x18000000000000001/3);
t36_test_locs(-0x2fe/3);
t36_test_locs(-0x2fffe/3);
t36_test_locs(-0x2fffffffe/3);
t36_test_locs(-0x2fffffffffffffffe/3);
t36_test_locs(0x2fe/3);
t36_test_locs(0x2fffe/3);
t36_test_locs(0x2fffffffe/3);
t36_test_locs(0x2fffffffffffffffe/3);
t36_test_locs(0L);
t36_test_locs(-0x7fL);
t36_test_locs(-0x7fffL);
t36_test_locs(-0x7fffffffL);
t36_test_locs(-0x7fffffffffffffffL);
t36_test_locs(0x7fL);
t36_test_locs(0x7fffL);
t36_test_locs(0x7fffffffL);
t36_test_locs(0x7fffffffffffffffL);
t36_test_locs(-0x80L);
t36_test_locs(-0x8000L);
t36_test_locs(-0x80000000L);
t36_test_locs(-0x8000000000000000L);
t36_test_locs(0x80L);
t36_test_locs(0x8000L);
t36_test_locs(0x80000000L);
t36_test_locs(0x8000000000000000L);
t36_test_locs(-0xffL);
t36_test_locs(-0xffffL);
t36_test_locs(-0xffffffffL);
t36_test_locs(-0xffffffffffffffffL);
t36_test_locs(0xffL);
t36_test_locs(0xffffL);
t36_test_locs(0xffffffffL);
t36_test_locs(0xffffffffffffffffL);
t36_test_locs(0.0+I);
t36_test_locs(-1.5+I);
t36_test_locs(1.5+I);
t36_test_locs(I);
t36_test_locs(-3/2+I);
t36_test_locs(3/2+I);
t36_test_locs(0.0L+I);
t36_test_locs(-1.5L+I);
t36_test_locs(1.5L+I);
t36_test_rets(0);
t36_test_rets(-0x7f);
t36_test_rets(-0x7fff);
t36_test_rets(-0x7fffffff);
t36_test_rets(-0x7fffffffffffffff);
t36_test_rets(0x7f);
t36_test_rets(0x7fff);
t36_test_rets(0x7fffffff);
t36_test_rets(0x7fffffffffffffff);
t36_test_rets(-0x80);
t36_test_rets(-0x8000);
t36_test_rets(-0x80000000);
t36_test_rets(-0x8000000000000000);
t36_test_rets(0x80);
t36_test_rets(0x8000);
t36_test_rets(0x80000000);
t36_test_rets(0x8000000000000000);
t36_test_rets(-0xff);
t36_test_rets(-0xffff);
t36_test_rets(-0xffffffff);
t36_test_rets(-0xffffffffffffffff);
t36_test_rets(0xff);
t36_test_rets(0xffff);
t36_test_rets(0xffffffff);
t36_test_rets(0xffffffffffffffff);
t36_test_rets(0.0);
t36_test_rets(-0x7f.0);
t36_test_rets(-0x7fff.0);
t36_test_rets(-0x7fffffff.0);
t36_test_rets(-0x7fffffffffffffff.0);
t36_test_rets(0x7f.0);
t36_test_rets(0x7fff.0);
t36_test_rets(0x7fffffff.0);
t36_test_rets(0x7fffffffffffffff.0);
t36_test_rets(-0x80.0);
t36_test_rets(-0x8000.0);
t36_test_rets(-0x80000000.0);
t36_test_rets(-0x8000000000000000.0);
t36_test_rets(0x80.0);
t36_test_rets(0x8000.0);
t36_test_rets(0x80000000.0);
t36_test_rets(0x8000000000000000.0);
t36_test_rets(-0xff.0);
t36_test_rets(-0xffff.0);
t36_test_rets(-0xffffffff.0);
t36_test_rets(-0xffffffffffffffff.0);
t36_test_rets(0xff.0);
t36_test_rets(0xffff.0);
t36_test_rets(0xffffffff.0);
t36_test_rets(0xffffffffffffffff.0);
t36_test_rets(-0x17e/3);
t36_test_rets(-0x17ffe/3);
t36_test_rets(-0x17ffffffe/3);
t36_test_rets(-0x17ffffffffffffffe/3);
t36_test_rets(0x17e/3);
t36_test_rets(0x17ffe/3);
t36_test_rets(0x17ffffffe/3);
t36_test_rets(0x17ffffffffffffffe/3);
t36_test_rets(-0x181/3);
t36_test_rets(-0x18001/3);
t36_test_rets(-0x180000001/3);
t36_test_rets(-0x18000000000000001/3);
t36_test_rets(0x181/3);
t36_test_rets(0x18001/3);
t36_test_rets(0x180000001/3);
t36_test_rets(0x18000000000000001/3);
t36_test_rets(-0x2fe/3);
t36_test_rets(-0x2fffe/3);
t36_test_rets(-0x2fffffffe/3);
t36_test_rets(-0x2fffffffffffffffe/3);
t36_test_rets(0x2fe/3);
t36_test_rets(0x2fffe/3);
t36_test_rets(0x2fffffffe/3);
t36_test_rets(0x2fffffffffffffffe/3);
t36_test_rets(0L);
t36_test_rets(-0x7fL);
t36_test_rets(-0x7fffL);
t36_test_rets(-0x7fffffffL);
t36_test_rets(-0x7fffffffffffffffL);
t36_test_rets(0x7fL);
t36_test_rets(0x7fffL);
t36_test_rets(0x7fffffffL);
t36_test_rets(0x7fffffffffffffffL);
t36_test_rets(-0x80L);
t36_test_rets(-0x8000L);
t36_test_rets(-0x80000000L);
t36_test_rets(-0x8000000000000000L);
t36_test_rets(0x80L);
t36_test_rets(0x8000L);
t36_test_rets(0x80000000L);
t36_test_rets(0x8000000000000000L);
t36_test_rets(-0xffL);
t36_test_rets(-0xffffL);
t36_test_rets(-0xffffffffL);
t36_test_rets(-0xffffffffffffffffL);
t36_test_rets(0xffL);
t36_test_rets(0xffffL);
t36_test_rets(0xffffffffL);
t36_test_rets(0xffffffffffffffffL);
t36_test_rets(0.0+I);
t36_test_rets(-1.5+I);
t36_test_rets(1.5+I);
t36_test_rets(I);
t36_test_rets(-3/2+I);
t36_test_rets(3/2+I);
t36_test_rets(0.0L+I);
t36_test_rets(-1.5L+I);
t36_test_rets(1.5L+I);
t36_call_test_prop(0);
t36_call_test_prop(1);
t36_call_test_prop(2);
t36_call_test_prop(3);
t36_call_test_prop(4);
t36_call_test_prop(5);
t36_call_test_prop(6);
t36_call_test_prop(7);
t36_call_test_prop(8);
t36_call_test_prop(9);
t36_call_test_prop(10);
t36_call_test_prop(11);
t36_call_test_prop(12);
t36_call_test_prop(13);
t36_call_test_prop(14);
t36_call_test_prop(15);
t36_call_test_prop(16);
t36_call_test_prop(17);
t36_call_test_prop(18);
t36_call_test_prop(19);
t36_call_test_prop(20);
t36_call_test_prop(21);
t36_call_test_prop(22);
t36_call_test_prop(23);
t36_call_test_prop(24);
t36_call_test_prop(25);
t36_call_test_prop(26);
t36_call_test_prop(27);
t36_call_test_prop(28);
t36_call_test_prop(29);
t36_call_test_prop(30);
t36_call_test_prop(31);
t36_call_test_prop(32);
t36_call_test_prop(33);
t36_call_test_prop(34);
t36_call_test_prop(35);
t36_call_test_prop(36);
t36_call_test_prop(37);
t36_call_test_prop(38);
t36_call_test_prop(39);
t36_call_test_prop(40);
t36_call_test_prop(41);
t36_call_test_prop(42);
t36_call_test_prop(43);
t36_call_test_prop(44);
t36_call_test_prop(45);
t36_call_test_prop(46);
t36_call_test_prop(47);
t36_call_test_prop(48);
t36_call_test_prop(49);
t36_call_test_prop(50);
t36_call_test_prop(51);
t36_call_test_prop(52);
t36_call_test_prop(53);
t36_call_test_prop(54);
t36_call_test_prop(55);
t36_call_test_prop(56);
t36_call_test_prop(57);
t36_call_test_prop(58);
t36_call_test_prop(59);
t36_call_test_prop(60);
t36_call_test_prop(61);
t36_call_test_prop(62);
t36_call_test_prop(63);
t36_call_test_prop(64);
t36_call_test_prop(65);
t36_call_test_prop(66);
t36_call_test_prop(67);
t36_call_test_prop(68);
t36_call_test_prop(69);
t36_call_test_prop(70);
t36_call_test_prop(71);
t36_call_test_prop(72);
t36_call_test_prop(73);
t36_call_test_prop(74);
t36_call_test_prop(75);
t36_call_test_prop(76);
t36_call_test_prop(77);
t36_call_test_prop(78);
t36_call_test_prop(79);
t36_call_test_prop(80);
t36_call_test_prop(81);
t36_call_test_prop(82);
t36_call_test_prop(83);
t36_call_test_prop(84);
t36_call_test_prop(85);
t36_call_test_prop(86);
t36_call_test_prop(87);
t36_call_test_prop(88);
t36_call_test_prop(89);
t36_call_test_prop(90);
t36_call_test_prop(91);
t36_call_test_prop(92);
t36_call_test_prop(93);
t36_call_test_prop(94);
t36_call_test_prop(95);
t36_call_test_prop(96);
t36_call_test_prop(97);
t36_call_test_prop(98);
t36_call_test_prop(99);
t36_call_test_prop(100);
t36_call_test_prop(101);
t36_call_test_prop(102);
t36_call_test_prop(103);
t36_call_test_prop(104);
t36_call_test_prop(105);
t36_call_test_prop(106);
t36_call_test_prop(107);
t36_test_locptrs(0);
t36_test_locptrs(-0x7f);
t36_test_locptrs(-0x7fff);
t36_test_locptrs(-0x7fffffff);
t36_test_locptrs(-0x7fffffffffffffff);
t36_test_locptrs(0x7f);
t36_test_locptrs(0x7fff);
t36_test_locptrs(0x7fffffff);
t36_test_locptrs(0x7fffffffffffffff);
t36_test_locptrs(-0x80);
t36_test_locptrs(-0x8000);
t36_test_locptrs(-0x80000000);
t36_test_locptrs(-0x8000000000000000);
t36_test_locptrs(0x80);
t36_test_locptrs(0x8000);
t36_test_locptrs(0x80000000);
t36_test_locptrs(0x8000000000000000);
t36_test_locptrs(-0xff);
t36_test_locptrs(-0xffff);
t36_test_locptrs(-0xffffffff);
t36_test_locptrs(-0xffffffffffffffff);
t36_test_locptrs(0xff);
t36_test_locptrs(0xffff);
t36_test_locptrs(0xffffffff);
t36_test_locptrs(0xffffffffffffffff);
t36_test_locptrs(0.0);
t36_test_locptrs(-0x7f.0);
t36_test_locptrs(-0x7fff.0);
t36_test_locptrs(-0x7fffffff.0);
t36_test_locptrs(-0x7fffffffffffffff.0);
t36_test_locptrs(0x7f.0);
t36_test_locptrs(0x7fff.0);
t36_test_locptrs(0x7fffffff.0);
t36_test_locptrs(0x7fffffffffffffff.0);
t36_test_locptrs(-0x80.0);
t36_test_locptrs(-0x8000.0);
t36_test_locptrs(-0x80000000.0);
t36_test_locptrs(-0x8000000000000000.0);
t36_test_locptrs(0x80.0);
t36_test_locptrs(0x8000.0);
t36_test_locptrs(0x80000000.0);
t36_test_locptrs(0x8000000000000000.0);
t36_test_locptrs(-0xff.0);
t36_test_locptrs(-0xffff.0);
t36_test_locptrs(-0xffffffff.0);
t36_test_locptrs(-0xffffffffffffffff.0);
t36_test_locptrs(0xff.0);
t36_test_locptrs(0xffff.0);
t36_test_locptrs(0xffffffff.0);
t36_test_locptrs(0xffffffffffffffff.0);
t36_test_locptrs(-0x17e/3);
t36_test_locptrs(-0x17ffe/3);
t36_test_locptrs(-0x17ffffffe/3);
t36_test_locptrs(-0x17ffffffffffffffe/3);
t36_test_locptrs(0x17e/3);
t36_test_locptrs(0x17ffe/3);
t36_test_locptrs(0x17ffffffe/3);
t36_test_locptrs(0x17ffffffffffffffe/3);
t36_test_locptrs(-0x181/3);
t36_test_locptrs(-0x18001/3);
t36_test_locptrs(-0x180000001/3);
t36_test_locptrs(-0x18000000000000001/3);
t36_test_locptrs(0x181/3);
t36_test_locptrs(0x18001/3);
t36_test_locptrs(0x180000001/3);
t36_test_locptrs(0x18000000000000001/3);
t36_test_locptrs(-0x2fe/3);
t36_test_locptrs(-0x2fffe/3);
t36_test_locptrs(-0x2fffffffe/3);
t36_test_locptrs(-0x2fffffffffffffffe/3);
t36_test_locptrs(0x2fe/3);
t36_test_locptrs(0x2fffe/3);
t36_test_locptrs(0x2fffffffe/3);
t36_test_locptrs(0x2fffffffffffffffe/3);
t36_test_locptrs(0L);
t36_test_locptrs(-0x7fL);
t36_test_locptrs(-0x7fffL);
t36_test_locptrs(-0x7fffffffL);
t36_test_locptrs(-0x7fffffffffffffffL);
t36_test_locptrs(0x7fL);
t36_test_locptrs(0x7fffL);
t36_test_locptrs(0x7fffffffL);
t36_test_locptrs(0x7fffffffffffffffL);
t36_test_locptrs(-0x80L);
t36_test_locptrs(-0x8000L);
t36_test_locptrs(-0x80000000L);
t36_test_locptrs(-0x8000000000000000L);
t36_test_locptrs(0x80L);
t36_test_locptrs(0x8000L);
t36_test_locptrs(0x80000000L);
t36_test_locptrs(0x8000000000000000L);
t36_test_locptrs(-0xffL);
t36_test_locptrs(-0xffffL);
t36_test_locptrs(-0xffffffffL);
t36_test_locptrs(-0xffffffffffffffffL);
t36_test_locptrs(0xffL);
t36_test_locptrs(0xffffL);
t36_test_locptrs(0xffffffffL);
t36_test_locptrs(0xffffffffffffffffL);
t36_test_locptrs(0.0+I);
t36_test_locptrs(-1.5+I);
t36_test_locptrs(1.5+I);
t36_test_locptrs(I);
t36_test_locptrs(-3/2+I);
t36_test_locptrs(3/2+I);
t36_test_locptrs(0.0L+I);
t36_test_locptrs(-1.5L+I);
t36_test_locptrs(1.5L+I);
t36_test_globs(0);
t36_test_globs(-0x7f);
t36_test_globs(-0x7fff);
t36_test_globs(-0x7fffffff);
t36_test_globs(-0x7fffffffffffffff);
t36_test_globs(0x7f);
t36_test_globs(0x7fff);
t36_test_globs(0x7fffffff);
t36_test_globs(0x7fffffffffffffff);
t36_test_globs(-0x80);
t36_test_globs(-0x8000);
t36_test_globs(-0x80000000);
t36_test_globs(-0x8000000000000000);
t36_test_globs(0x80);
t36_test_globs(0x8000);
t36_test_globs(0x80000000);
t36_test_globs(0x8000000000000000);
t36_test_globs(-0xff);
t36_test_globs(-0xffff);
t36_test_globs(-0xffffffff);
t36_test_globs(-0xffffffffffffffff);
t36_test_globs(0xff);
t36_test_globs(0xffff);
t36_test_globs(0xffffffff);
t36_test_globs(0xffffffffffffffff);
t36_test_globs(0.0);
t36_test_globs(-0x7f.0);
t36_test_globs(-0x7fff.0);
t36_test_globs(-0x7fffffff.0);
t36_test_globs(-0x7fffffffffffffff.0);
t36_test_globs(0x7f.0);
t36_test_globs(0x7fff.0);
t36_test_globs(0x7fffffff.0);
t36_test_globs(0x7fffffffffffffff.0);
t36_test_globs(-0x80.0);
t36_test_globs(-0x8000.0);
t36_test_globs(-0x80000000.0);
t36_test_globs(-0x8000000000000000.0);
t36_test_globs(0x80.0);
t36_test_globs(0x8000.0);
t36_test_globs(0x80000000.0);
t36_test_globs(0x8000000000000000.0);
t36_test_globs(-0xff.0);
t36_test_globs(-0xffff.0);
t36_test_globs(-0xffffffff.0);
t36_test_globs(-0xffffffffffffffff.0);
t36_test_globs(0xff.0);
t36_test_globs(0xffff.0);
t36_test_globs(0xffffffff.0);
t36_test_globs(0xffffffffffffffff.0);
t36_test_globs(-0x17e/3);
t36_test_globs(-0x17ffe/3);
t36_test_globs(-0x17ffffffe/3);
t36_test_globs(-0x17ffffffffffffffe/3);
t36_test_globs(0x17e/3);
t36_test_globs(0x17ffe/3);
t36_test_globs(0x17ffffffe/3);
t36_test_globs(0x17ffffffffffffffe/3);
t36_test_globs(-0x181/3);
t36_test_globs(-0x18001/3);
t36_test_globs(-0x180000001/3);
t36_test_globs(-0x18000000000000001/3);
t36_test_globs(0x181/3);
t36_test_globs(0x18001/3);
t36_test_globs(0x180000001/3);
t36_test_globs(0x18000000000000001/3);
t36_test_globs(-0x2fe/3);
t36_test_globs(-0x2fffe/3);
t36_test_globs(-0x2fffffffe/3);
t36_test_globs(-0x2fffffffffffffffe/3);
t36_test_globs(0x2fe/3);
t36_test_globs(0x2fffe/3);
t36_test_globs(0x2fffffffe/3);
t36_test_globs(0x2fffffffffffffffe/3);
t36_test_globs(0L);
t36_test_globs(-0x7fL);
t36_test_globs(-0x7fffL);
t36_test_globs(-0x7fffffffL);
t36_test_globs(-0x7fffffffffffffffL);
t36_test_globs(0x7fL);
t36_test_globs(0x7fffL);
t36_test_globs(0x7fffffffL);
t36_test_globs(0x7fffffffffffffffL);
t36_test_globs(-0x80L);
t36_test_globs(-0x8000L);
t36_test_globs(-0x80000000L);
t36_test_globs(-0x8000000000000000L);
t36_test_globs(0x80L);
t36_test_globs(0x8000L);
t36_test_globs(0x80000000L);
t36_test_globs(0x8000000000000000L);
t36_test_globs(-0xffL);
t36_test_globs(-0xffffL);
t36_test_globs(-0xffffffffL);
t36_test_globs(-0xffffffffffffffffL);
t36_test_globs(0xffL);
t36_test_globs(0xffffL);
t36_test_globs(0xffffffffL);
t36_test_globs(0xffffffffffffffffL);
t36_test_globs(0.0+I);
t36_test_globs(-1.5+I);
t36_test_globs(1.5+I);
t36_test_globs(I);
t36_test_globs(-3/2+I);
t36_test_globs(3/2+I);
t36_test_globs(0.0L+I);
t36_test_globs(-1.5L+I);
t36_test_globs(1.5L+I);
t36_test_globptrs(0);
t36_test_globptrs(-0x7f);
t36_test_globptrs(-0x7fff);
t36_test_globptrs(-0x7fffffff);
t36_test_globptrs(-0x7fffffffffffffff);
t36_test_globptrs(0x7f);
t36_test_globptrs(0x7fff);
t36_test_globptrs(0x7fffffff);
t36_test_globptrs(0x7fffffffffffffff);
t36_test_globptrs(-0x80);
t36_test_globptrs(-0x8000);
t36_test_globptrs(-0x80000000);
t36_test_globptrs(-0x8000000000000000);
t36_test_globptrs(0x80);
t36_test_globptrs(0x8000);
t36_test_globptrs(0x80000000);
t36_test_globptrs(0x8000000000000000);
t36_test_globptrs(-0xff);
t36_test_globptrs(-0xffff);
t36_test_globptrs(-0xffffffff);
t36_test_globptrs(-0xffffffffffffffff);
t36_test_globptrs(0xff);
t36_test_globptrs(0xffff);
t36_test_globptrs(0xffffffff);
t36_test_globptrs(0xffffffffffffffff);
t36_test_globptrs(0.0);
t36_test_globptrs(-0x7f.0);
t36_test_globptrs(-0x7fff.0);
t36_test_globptrs(-0x7fffffff.0);
t36_test_globptrs(-0x7fffffffffffffff.0);
t36_test_globptrs(0x7f.0);
t36_test_globptrs(0x7fff.0);
t36_test_globptrs(0x7fffffff.0);
t36_test_globptrs(0x7fffffffffffffff.0);
t36_test_globptrs(-0x80.0);
t36_test_globptrs(-0x8000.0);
t36_test_globptrs(-0x80000000.0);
t36_test_globptrs(-0x8000000000000000.0);
t36_test_globptrs(0x80.0);
t36_test_globptrs(0x8000.0);
t36_test_globptrs(0x80000000.0);
t36_test_globptrs(0x8000000000000000.0);
t36_test_globptrs(-0xff.0);
t36_test_globptrs(-0xffff.0);
t36_test_globptrs(-0xffffffff.0);
t36_test_globptrs(-0xffffffffffffffff.0);
t36_test_globptrs(0xff.0);
t36_test_globptrs(0xffff.0);
t36_test_globptrs(0xffffffff.0);
t36_test_globptrs(0xffffffffffffffff.0);
t36_test_globptrs(-0x17e/3);
t36_test_globptrs(-0x17ffe/3);
t36_test_globptrs(-0x17ffffffe/3);
t36_test_globptrs(-0x17ffffffffffffffe/3);
t36_test_globptrs(0x17e/3);
t36_test_globptrs(0x17ffe/3);
t36_test_globptrs(0x17ffffffe/3);
t36_test_globptrs(0x17ffffffffffffffe/3);
t36_test_globptrs(-0x181/3);
t36_test_globptrs(-0x18001/3);
t36_test_globptrs(-0x180000001/3);
t36_test_globptrs(-0x18000000000000001/3);
t36_test_globptrs(0x181/3);
t36_test_globptrs(0x18001/3);
t36_test_globptrs(0x180000001/3);
t36_test_globptrs(0x18000000000000001/3);
t36_test_globptrs(-0x2fe/3);
t36_test_globptrs(-0x2fffe/3);
t36_test_globptrs(-0x2fffffffe/3);
t36_test_globptrs(-0x2fffffffffffffffe/3);
t36_test_globptrs(0x2fe/3);
t36_test_globptrs(0x2fffe/3);
t36_test_globptrs(0x2fffffffe/3);
t36_test_globptrs(0x2fffffffffffffffe/3);
t36_test_globptrs(0L);
t36_test_globptrs(-0x7fL);
t36_test_globptrs(-0x7fffL);
t36_test_globptrs(-0x7fffffffL);
t36_test_globptrs(-0x7fffffffffffffffL);
t36_test_globptrs(0x7fL);
t36_test_globptrs(0x7fffL);
t36_test_globptrs(0x7fffffffL);
t36_test_globptrs(0x7fffffffffffffffL);
t36_test_globptrs(-0x80L);
t36_test_globptrs(-0x8000L);
t36_test_globptrs(-0x80000000L);
t36_test_globptrs(-0x8000000000000000L);
t36_test_globptrs(0x80L);
t36_test_globptrs(0x8000L);
t36_test_globptrs(0x80000000L);
t36_test_globptrs(0x8000000000000000L);
t36_test_globptrs(-0xffL);
t36_test_globptrs(-0xffffL);
t36_test_globptrs(-0xffffffffL);
t36_test_globptrs(-0xffffffffffffffffL);
t36_test_globptrs(0xffL);
t36_test_globptrs(0xffffL);
t36_test_globptrs(0xffffffffL);
t36_test_globptrs(0xffffffffffffffffL);
t36_test_globptrs(0.0+I);
t36_test_globptrs(-1.5+I);
t36_test_globptrs(1.5+I);
t36_test_globptrs(I);
t36_test_globptrs(-3/2+I);
t36_test_globptrs(3/2+I);
t36_test_globptrs(0.0L+I);
t36_test_globptrs(-1.5L+I);
t36_test_globptrs(1.5L+I);

/* test37 - for loops with empty clauses */
/* there were problems with it, due do taking conditional branches
 * based on code did not exist, that is, it would use the currently
 * loaded value */
auto t37_i = 0;
for (;;) {
    if (++t37_i >= 10)
	break;
}
if (t37_i != 10)			print("error %d\n", __LINE__);
for (t37_i = 1;;) {
    if (++t37_i >= 10)
	break;
}
if (t37_i != 10)			print("error %d\n", __LINE__);
for (t37_i = -1;; ++t37_i) {
    if (t37_i == 1)
	break;
}
if (t37_i != 1)				print("error %d\n", __LINE__);

/* test38 - some tests from optimize.e, to ensure they are always run */
// common subexpression elimination with temporary variable deletion
auto t38_fa() { return 1; }	
auto t38_fb() { return 2; }
auto t38_fc() { return 3; }
auto t38_a = t38_fa(), t38_b = t38_fb(), t38_c = t38_fc(), t38_d, t38_e, t38_f;
t38_d = t38_a + t38_b + t38_c;
t38_e = t38_a + t38_b + t38_c;
t38_f = t38_a + t38_b + t38_c + t38_d;
if (t38_d != 6 || t38_e != 6 || t38_f != 12)
    print("error %d\n", __LINE__);
// constant folding with temporary constant deletion
t38_a = 1.5L, t38_b = 2.5L, t38_c = 3.25L, t38_d = null;
t38_d = t38_a + t38_b + t38_c;
if (t38_d - 1 != 6.25L)
    print("error %d\n", __LINE__);
// constant folding with stores or non side effect opcodes
t38_c = (t38_a = 1) + (t38_b = 2);
if (t38_c != 3)				print("error %d\n", __LINE__);
// more variants of above
t38_c = (t38_a = 1, 2) + (t38_b = 3, 4 + 5);
if (t38_a != 1 || t38_b != 3 || t38_c != 11)
    print("error %d\n", __LINE__);
// more variants of above
t38_c = (t38_a = (1, 2)) + (t38_b = (3, 4 + 5));
if (t38_a != 2 || t38_b != 9 || t38_c != 11)
    print("error %d\n", __LINE__);
// constant folding of typeof() and sizeof()
t38_a = 1.3, t38_b = "foobar";
if (typeof(t38_a) != typeof(1.0) ||
    sizeof(t38_b) != 6)			print("error %d\n", __LINE__);

/* test39 - check for the syntax (cond ? vec1 : vec2)[cond ? off1 : off2] */
auto t39_va[] = { 1, 2, 3, 4 };
auto t39_vb[] = { 5, 6, 7, 8 };
auto t39_ia = 1, t39_ib = 2;
auto t39_fi() { return 0; }
auto t39_fj() { return 3; }
auto t39_fv()[] { return t39_fi() ? t39_va : t39_vb; }
auto t39_fk() { return t39_fj() ? t39_ia : t39_ib; }
auto t39_a = t39_fv()[t39_fk()];
if (t39_a != 6)
    print("error %d\n", __LINE__);
if ((t39_fi() ? t39_va : t39_vb)[t39_fj() ? t39_ia : t39_ib] != 6)
    print("error %d\n", __LINE__);
auto t39_b = (!t39_fi() ? t39_va : t39_vb)[!t39_fj() ? t39_ia : t39_ib];
if (t39_b != 3)
    print("error %d\n", __LINE__);

/* test40 - basic shared object test */
auto t40_v[][] = { { 0, 1 }, { 2, 3 } };
auto t40_v0[] = t40_v[0];
auto t40_v01 = t40_v[0][1];
t40_v0[1] = "one";
if (t40_v[0][1] != t40_v0[1])		print("error %d\n", __LINE__);
/* this test was failing due to assignment of t40_v01 causing the generation
 * of a temporary for the dereference of t40_v[0][1], and this temporary being
 * loaded again in the `if' test; the data itself was correct, but if that
 * value were used in a store, it would also corrupt data. */

/* test41 - simple test where the for conditional is constant
  folded/propagated or common subexpression eliminated  */
auto t41_i, t41_j, t41_n = 10;
for (t41_i = t41_j = 1; t41_i <= t41_n - 1; t41_i++)
    t41_j += t41_i;
t41_j += t41_n - 1;
if (t41_j != 55)			print("error %d\n", __LINE__);
/* force cse */
auto t41_n_cse(void) { return 10; }
t41_n = t41_n_cse();
for (t41_i = t41_j = 1; t41_i <= t41_n - 1; t41_i++)
    t41_j += t41_i;
t41_j += t41_n - 1;
if (t41_j != 55)			print("error %d\n", __LINE__);
/* this was being incorrectly folded in the version using cse due to a
 * bug caused by optimization of expressions with stores, that ended up
 * removing the store of the temporary, and causing an error when loading
 * it, for the <= comparison in the for loop test clause */

/* test42 - simple test for format with 0 filling when overestimating
 * the result size. the current code needs some cleanup, but as long as
 * it gives the proper result, it is ok.  the overestimating happens
 * when the topmost bit in base 16 is equal or greater then 8 */
auto t42_s[] = new uint8_t[32];
printf(t42_s, "0x%08x", 0x8fffffff);
if (t42_s != "0x8fffffff")		print("error %d\n", __LINE__);
/* with mpz_t */
printf(t42_s, "0x%016x", 0x8fffffffffffffff);
if (t42_s != "0x8fffffffffffffff")	print("error %d\n", __LINE__);

/* test 43 - simple hash table test covering most type combinations */
hash_t t43_v = hash();
t43_v[0] = 0;
t43_v[1] = 1.0;
t43_v[2] = 0x8000000000000002;
t43_v[3] = 1/3;
t43_v[4] = 4.0L;
t43_v[5] = 5.0*I;
t43_v[6] = 1/6*I;
t43_v[7] = 7.0L*I;
t43_v[8] = "eight";
t43_v[0.0] = 0;
t43_v[1.0] = 1.0;
t43_v[2.0] = 0x8000000000000002;
t43_v[3.0] = 1/3;
t43_v[4.0] = 4.0L;
t43_v[5.0] = 5.0*I;
t43_v[6.0] = 1/6*I;
t43_v[7.0] = 7.0L*I;
t43_v[8.0] = "eight";
t43_v[0x8000000000000000] = 0;
t43_v[0x8000000000000001] = 1.0;
t43_v[0x8000000000000002] = 0x8000000000000002;
t43_v[0x8000000000000003] = 1/3;
t43_v[0x8000000000000004] = 4.0L;
t43_v[0x8000000000000005] = 5.0*I;
t43_v[0x8000000000000006] = 1/6*I;
t43_v[0x8000000000000007] = 7.0L*I;
t43_v[0x8000000000000008] = "eight";
t43_v[1/10] = 0;
t43_v[1/11] = 1.0;
t43_v[1/12] = 0x8000000000000002;
t43_v[1/13] = 1/3;
t43_v[1/14] = 4.0L;
t43_v[1/15] = 5.0*I;
t43_v[1/16] = 1/6*I;
t43_v[1/17] = 7.0L*I;
t43_v[1/18] = "eight";
t43_v[0.0L] = 0;
t43_v[1.0L] = 1.0;
t43_v[2.0L] = 0x8000000000000002;
t43_v[3.0L] = 1/3;
t43_v[4.0L] = 4.0L;
t43_v[5.0L] = 5.0*I;
t43_v[6.0L] = 1/6*I;
t43_v[7.0L] = 7.0L*I;
t43_v[8.0L] = "eight";
t43_v[10.0*I] = 0;
t43_v[11.0*I] = 1.0;
t43_v[12.0*I] = 0x8000000000000002;
t43_v[13.0*I] = 1/3;
t43_v[14.0*I] = 4.0L;
t43_v[15.0*I] = 5.0*I;
t43_v[16.0*I] = 1/6*I;
t43_v[17.0*I] = 7.0L*I;
t43_v[18.0*I] = "eight";
t43_v[1/10*I] = 0;
t43_v[1/11*I] = 1.0;
t43_v[1/12*I] = 0x8000000000000002;
t43_v[1/13*I] = 1/3;
t43_v[1/14*I] = 4.0L;
t43_v[1/15*I] = 5.0*I;
t43_v[1/16*I] = 1/6*I;
t43_v[1/17*I] = 7.0L*I;
t43_v[1/18*I] = "eight";
t43_v[10.0L*I] = 0;
t43_v[11.0L*I] = 1.0;
t43_v[12.0L*I] = 0x8000000000000002;
t43_v[13.0L*I] = 1/3;
t43_v[14.0L*I] = 4.0L;
t43_v[15.0L*I] = 5.0*I;
t43_v[16.0L*I] = 1/6*I;
t43_v[17.0L*I] = 7.0L*I;
t43_v[18.0L*I] = "eight";
t43_v["zero"] = 0;
t43_v["one"] = 1.0;
t43_v["two"] = 0x8000000000000002;
t43_v["three"] = 1/3;
t43_v["four"] = 4.0L;
t43_v["five"] = 5.0*I;
t43_v["six"] = 1/6*I;
t43_v["seven"] = 7.0L*I;
t43_v["eight"] = "eight";
/* simple comparisons */
if (t43_v[0] != t43_v[0] ||
    t43_v[0] != t43_v[0.0] ||
    t43_v[0] != t43_v[0x8000000000000000] ||
    t43_v[0] != t43_v[1/10] ||
    t43_v[0] != t43_v[10.0*I] ||
    t43_v[0] != t43_v[1/10*I] ||
    t43_v[0] != t43_v[10.0L*I] ||
    t43_v[0] != t43_v["zero"])
    print("error %d\n", __LINE__);
if (t43_v[1.0] != t43_v[1] ||
    t43_v[1.0] != t43_v[1.0] ||
    t43_v[1.0] != t43_v[0x8000000000000001] ||
    t43_v[1.0] != t43_v[1/11] ||
    t43_v[1.0] != t43_v[11.0*I] ||
    t43_v[1.0] != t43_v[1/11*I] ||
    t43_v[1.0] != t43_v[11.0L*I] ||
    t43_v[1.0] != t43_v["one"])
    print("error %d\n", __LINE__);
if (t43_v[0x8000000000000002] != t43_v[2] ||
    t43_v[0x8000000000000002] != t43_v[2.0] ||
    t43_v[0x8000000000000002] != t43_v[0x8000000000000002] ||
    t43_v[0x8000000000000002] != t43_v[1/12] ||
    t43_v[0x8000000000000002] != t43_v[12.0*I] ||
    t43_v[0x8000000000000002] != t43_v[1/12*I] ||
    t43_v[0x8000000000000002] != t43_v[12.0L*I] ||
    t43_v[0x8000000000000002] != t43_v["two"])
    print("error %d\n", __LINE__);
if (t43_v[1/13] != t43_v[3] ||
    t43_v[1/13] != t43_v[3.0] ||
    t43_v[1/13] != t43_v[0x8000000000000003] ||
    t43_v[1/13] != t43_v[1/13] ||
    t43_v[1/13] != t43_v[13.0*I] ||
    t43_v[1/13] != t43_v[1/13*I] ||
    t43_v[1/13] != t43_v[13.0L*I] ||
    t43_v[1/13] != t43_v["three"])
    print("error %d\n", __LINE__);
if (t43_v[4.0L] != t43_v[4] ||
    t43_v[4.0L] != t43_v[4.0] ||
    t43_v[4.0L] != t43_v[0x8000000000000004] ||
    t43_v[4.0L] != t43_v[1/14] ||
    t43_v[4.0L] != t43_v[14.0*I] ||
    t43_v[4.0L] != t43_v[1/14*I] ||
    t43_v[4.0L] != t43_v[14.0L*I] ||
    t43_v[4.0L] != t43_v["four"])
    print("error %d\n", __LINE__);
if (t43_v[15.0*I] != t43_v[5] ||
    t43_v[15.0*I] != t43_v[5.0] ||
    t43_v[15.0*I] != t43_v[0x8000000000000005] ||
    t43_v[15.0*I] != t43_v[1/15] ||
    t43_v[15.0*I] != t43_v[15.0*I] ||
    t43_v[15.0*I] != t43_v[1/15*I] ||
    t43_v[15.0*I] != t43_v[15.0L*I] ||
    t43_v[15.0*I] != t43_v["five"])
    print("error %d\n", __LINE__);
if (t43_v[1/16*I] != t43_v[6] ||
    t43_v[1/16*I] != t43_v[6.0] ||
    t43_v[1/16*I] != t43_v[0x8000000000000006] ||
    t43_v[1/16*I] != t43_v[1/16] ||
    t43_v[1/16*I] != t43_v[16.0*I] ||
    t43_v[1/16*I] != t43_v[1/16*I] ||
    t43_v[1/16*I] != t43_v[16.0L*I] ||
    t43_v[1/16*I] != t43_v["six"])
    print("error %d\n", __LINE__);
if (t43_v[17.0L*I] != t43_v[7] ||
    t43_v[17.0L*I] != t43_v[7.0] ||
    t43_v[17.0L*I] != t43_v[0x8000000000000007] ||
    t43_v[17.0L*I] != t43_v[1/17] ||
    t43_v[17.0L*I] != t43_v[17.0*I] ||
    t43_v[17.0L*I] != t43_v[1/17*I] ||
    t43_v[17.0L*I] != t43_v[17.0L*I] ||
    t43_v[17.0L*I] != t43_v["seven"])
    print("error %d\n", __LINE__);
if (t43_v["eight"] != t43_v[8] ||
    t43_v["eight"] != t43_v[8.0] ||
    t43_v["eight"] != t43_v[0x8000000000000008] ||
    t43_v["eight"] != t43_v[1/18] ||
    t43_v["eight"] != t43_v[18.0*I] ||
    t43_v["eight"] != t43_v[1/18*I] ||
    t43_v["eight"] != t43_v[18.0L*I] ||
    t43_v["eight"] != t43_v["eight"])
    print("error %d\n", __LINE__);
/* check that deleting entries work, and also do a noop "deleting" a
 * entry that doesn't exist */
t43_v[0] = t43_v[1.0] = t43_v[0x8000000000000002] =
t43_v[1/13] = t43_v[14.0L] = t43_v[15.0*I] = t43_v[1/16*I] =
t43_v[17.0L*I] = t43_v["eight"] = t43_v[t43_v] = null;
/* check that an exception is triggered when attempting to
 * store a null entry name */
auto t43_c = 0;
try {
    t43_v[null] = 0;
}
catch (e) {
    t43_c = 1;
}
if (!t43_c)
    print("error %d\n", __LINE__);
t43_c = 0;
try {
    /* truly a noop... */
    t43_v[null] = null;
}
catch (e) {
    t43_c = 1;
}
if (!t43_c)
    print("error %d\n", __LINE__);
/* check that the deleted entries were really deleted */
if (t43_v[0] || t43_v[1.0] || t43_v[0x8000000000000002] ||
    t43_v[1/13] || t43_v[14.0L] || t43_v[15.0*I] || t43_v[1/16*I] ||
    t43_v[17.0L*I] || t43_v["eight"] || t43_v[t43_v])
    print("error %d\n", __LINE__);


/* test 44 - check that a previous regression is now corrected.
 * the problem was due to using record field logic for class fields
 * in the CSE code, but that was not correct because class fields
 * are loaded dereferencing from the value that is the first local
 * variable, and not a pushed value */
struct a44_t {
    auto f;
    a44_t aa;
};
class b44_t {
    a44_t a;
    void t() {
	auto v = 0;
	if (v + 1 > a.aa.f)	// set value of a.aa.ff into cse temporary
	    a.f = v + 1;
	else
	    a.f = a.aa.f;	// was not pushing 'a' before record store
    }
};
b44_t bb44 = { a: { 1, aa: {1} }};
bb44.t();

/* test 45 - check a regression caused by not having ssa naming of classes */
/*   The problem was caused by incorrectly reseting the 'branch' state flag
 * in lib/ecse.c:ecse() when starting to parse a new basic block, while it
 * should set it only once.
 *   This doesn't happen (easily) to structs because the way the ssa code
 * works, but it is possible to have code that would also trigger the bug,
 * but would be redundant, non side effect code.
 */
struct t45s_t {
    auto v;
};
class t45c_t {
    t45s_t s;
    t45c_t c;
    auto a;
    void test_cse() {
	if (a)
	    c.s.v = s.v - 1;
	else
	    c.s.v = s.v + 1;
	/* if the regression happens, this will cause an exception,
	 * not print the string "error\n" */
	if (!c.s.v)			print("error %d\n", __LINE__);
    }
};
t45c_t t45 = { s: { 2 }, c: { s: { 2 } }, a: 1 };
t45.test_cse();

/* test 46 - check for a parser regression, the regression is parsing
 * the if expression as:
 *	(!= (&& (>= start (- range page)) (+ (- pos 18) new_dim)) dimension)
 * instead of:
 *	(&& (>= start (- range page)) (!= (+ (- pos 18) new_dim) dimension))
 */
auto t46_start, t46_range, t46_page, t46_new_pos, t46_new_dim, t46_dimension;
void t46_set_vars() {
    t46_start = 0;
    t46_range = 100;
    t46_page = 50;
    t46_new_pos = 0;
    t46_dimension = 56;
}
t46_set_vars();
t46_new_dim = trunc(t46_page * (t46_dimension / t46_range));
if (t46_start >= t46_range - t46_page && (t46_new_pos - 18) + t46_new_dim != t46_dimension)
    t46_new_dim = t46_dimension - (t46_new_pos - 18);
if (t46_new_dim != 28)			print("error %d\n", __LINE__);

/* test 47 - basic class constructor tests */
auto t47_n = 0;
class t47_t {
    auto v;
    t47_t() {
	t47_n = 1;
	++v;
    }
};
t47_t t47_v = { v: 1 };
if (t47_n != 1 || t47_v.v != 2)		print("error %d\n", __LINE__);
class t47_tt : t47_t {
    t47_tt();			/* redundant prototype */
    t47_tt() {
	t47_n = 2;
	++v;
    }
};
t47_v = new t47_tt { v: 2 };
if (t47_n != 2 || t47_v.v != 3)		print("error %d\n", __LINE__);
class t47_ttt : t47_tt {
    t47_ttt();			/* prototype before closing class */
};
t47_ttt.t47_ttt() {		/* constructor defined outside class body */
    t47_n = 3;
    ++v;
}
t47_v = new t47_ttt { v: 3 };
if (t47_n != 3 || t47_v.v != 4)		print("error %d\n", __LINE__);
class t47_tttt : t47_ttt {
    t47_tttt() {
	t47_ttt();		/* call superclass constructor */
	t47_n = 4;		/* override */
	++v;
    }
};
t47_v = new t47_tttt { v: 3 };
if (t47_n != 4 || t47_v.v != 5)		print("error %d\n", __LINE__);
auto t47_always_true() { return true; }
class t47_ttttt : t47_tttt {
    t47_ttttt() {
	t47_tttt();		/* call superclass constructor */
	t47_n = 5;		/* override */
	++v;
	if (t47_always_true())	/* currently not optimized */
	    return;
	++v;
    }
};
t47_v = new t47_ttttt { v: 4 };
/* if return is not executed, t47_v.v will be 8 */
if (t47_n != 5 || t47_v.v != 7)		print("error %d\n", __LINE__);

/* test 48 - basic tests on check of rank and dimensions size of vectors */
auto t48_i, t48_j, t48_k, t48_n;
auto t48_v[4][3][2] = {
    { {  1,  2 }, {  3,  4 }, {  5,  6 } },
    { {  7,  8 }, {  9, 10 }, { 11, 12 } },
    { { 13, 14 }, { 15, 16 }, { 17, 18 } },
    { { 19, 20 }, { 21, 22 }, { 23, 24 } }
};
/* check proper parsing and return value of "extended" sizeof() */
if (rankof(t48_v)    !=  3 ||
    sizeof(t48_v   ) != 24 || sizeof(t48_v, 0) != 4 ||
    sizeof(t48_v, 1) !=  3 || sizeof(t48_v, 2) != 2 || sizeof(t48_v, 3) != 0)
    print("error %d\n", __LINE__);
/* check proper initialization (test regression on >2 dimensions) */
for (t48_i = 0; t48_i < 4; t48_i++)
    for (t48_j = 0; t48_j < 3; t48_j++)
	for (t48_k =  0; t48_k < 2; t48_k++)
	    if (t48_v[t48_i][t48_j][t48_k] != t48_i * 3 * 2 + t48_j * 2 + t48_k + 1)
		print("error %d\n", __LINE__);
/* check proper implementation of runtime value */
/* this assignment was triggering an optimization bug in elive.c */
t48_i = 0;
auto t48_vec() { return t48_v; }
auto t48_dim() { return t48_i++; }
if (rankof(t48_vec())    != 3 ||
    sizeof(t48_v, t48_dim()) != 4 || sizeof(t48_v, t48_dim()) != 3 ||
    sizeof(t48_v, t48_dim()) != 2 || sizeof(t48_v, t48_dim()) != 0)
    print("error %d\n", __LINE__);
/* FIXME using 10x10 just to avoid "temporary" warning about possible
 * out of bounds access..
 * Possible "solutions":
 *	o use a[0][0] to tell the parser it has runtime defined values
 *	  this currently cannot be done, because length 0 is internally
 *	  flagged as an error, and unspecified means vector of vectors,
 *	  that is "type a[][]" matches "C" declaration "type *a[]"
 *	  also, 0 length should be allowed even in static declarations
 *	o use some special identifer
 */
auto t48_mmul(a[10][10], b[10][10])[10][10] {
#define num_cols(v)		sizeof(v, 1)
#define num_rows(v)		sizeof(v, 0)
    if (rankof(a) != 2 || rankof(a) != rankof(b) ||
	num_cols(a) != num_rows(b)) {
	print("wrong dimensions\n");
	return null;
    }
    auto i, j, k;
    auto r[10][10] = new auto[num_rows(a)][num_cols(b)];
    for (i = 0; i < num_rows(a); i++)
	for (j = 0; j < num_cols(b); j++)
	    for (k = 0; k < num_rows(b); k++)
		r[i][j] += a[i][k] * b[k][j];
    return r;
}
auto t48_a[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
auto t48_b[3][2] = { { 1, 1 }, { 1, 1 }, { 1, 1 } };
auto t48_r[10][10] = t48_mmul(t48_a, t48_b);
if (rankof(t48_r) != 2 || num_rows(t48_r) != 3 || num_cols(t48_r) != 2 ||
    t48_r[0][0] !=  6 || t48_r[0][1] !=  6 ||
    t48_r[1][0] != 15 || t48_r[1][1] != 15 ||
    t48_r[2][0] != 24 || t48_r[2][1] != 24)
    print("error %d\n", __LINE__);

/* test 49 - test special cases with pointer objects */
struct t49_p_t {
    auto *po;
    int16_t *pi16;
};
auto t49_go, *t49_gpo;
int16_t t49_gi16, *t49_gpi16;
auto t49_gv[] = { &t49_go, &t49_gi16 }, *t49_gpv[] = t49_gv;
t49_p_t t49_gpt = { &t49_go, &t49_gi16 };
hash_t t49_gh = hash();
t49_go = 1;
t49_gpo = t49_gpv[0];
t49_gi16 = 2;
t49_gpi16 = t49_gpv[1];
if (t49_go != *t49_gpo || *t49_gpv[0] != *t49_gpo ||
    t49_gi16 != *t49_gpi16 || *t49_gpv[1] != *t49_gpi16)
    print("error %d\n", __LINE__);
*t49_gpt.po = 3;
*t49_gpt.pi16 = 4;
if (t49_go != *t49_gpo || *t49_gpt.po != *t49_gpo ||
    t49_gi16 != *t49_gpi16 || *t49_gpt.pi16 != *t49_gpi16)
    print("error %d\n", __LINE__);
t49_gh[3] = &t49_go;
t49_gh[4] = &t49_gi16;
t49_go = 5;
t49_gi16 = 6;
t49_gpo = t49_gh[3];
t49_gpi16 = t49_gh[4];
if (t49_go != *t49_gpo || t49_gi16 != *t49_gpi16)
    print("error %d\n", __LINE__);
void t49_t() {
    auto lo, *lpo;
    int16_t li16, *lpi16;
    auto lv[] = { &lo, &li16 }, *lpv[] = lv;
    t49_p_t lpt = { &lo, &li16 };
    hash_t lh = hash();
    lo = 1;
    lpo = lpv[0];
    li16 = 2;
    lpi16 = lpv[1];
    if (lo != *lpo || *lpv[0] != *lpo || li16 != *lpi16 || *lpv[1] != *lpi16)
	print("error %d\n", __LINE__);
    *lpt.po = 3;
    *lpt.pi16 = 4;
    if (lo != *lpo || *lpt.po != *lpo || li16 != *lpi16 || *lpt.pi16 != *lpi16)
	print("error %d\n", __LINE__);
    lh[3] = &lo;
    lh[4] = &li16;
    lo = 5;
    li16 = 6;
    lpo = lh[3];
    lpi16 = lh[4];
    if (lo != *lpo || li16 != *lpi16)
	print("error %d\n", __LINE__);
}
t49_t();

/* test 50 - generic cse test */
/* this test actually should not generate any cse temporaries because
 * the target basic blocks have multiple sources, and the main cause,
 * "visually" is that the repeated expressions are in conditional code */
auto t50_1() { return 1; }
auto t50_0() { return 0; }
auto t50_a, t50_b, t50_c, t50_d, t50_e;
t50_a = t50_0();
t50_c = t50_d = t50_e = t50_1();
if (t50_a && t50_c + t50_d + t50_e)
    t50_b = -1;
else
    t50_b = t50_c + t50_d + t50_e;
if (t50_b != t50_c + t50_d + t50_e)	print("error %d\n", __LINE__);
void t50_t() {
    auto a, b, c, d, e;
    a = t50_0();
    c = d = e = t50_1();
    if (a && c + d + e)
	b = -1;
    else
	b = c + d + e;
    if (b != c + d + e)			print("error %d\n", __LINE__);
}
t50_t();

/* test 51 - basic check for jit code generation */
#define t51_defscheck(name, ta, tb, tc, op)				\
void name(ta a, tb b, tc c) {						\
    int8_t	sc;							\
    int16_t	ss;							\
    int32_t	si;							\
    int64_t	sl;							\
    float32_t	f;	float64_t	d;				\
    auto	v;							\
    sc = ss = si = sl = f = d = v = b;					\
    if (a op sc != c)	print("error %d\n", __LINE__);			\
    if (a op ss != c)	print("error %d\n", __LINE__);			\
    if (a op si != c)	print("error %d\n", __LINE__);			\
    if (a op sl != c)	print("error %d\n", __LINE__);			\
    if (a op f  != c)	print("error %d\n", __LINE__);			\
    if (a op d  != c)	print("error %d\n", __LINE__);			\
    if (a op v  != c)	print("error %d\n", __LINE__);			\
}
#define t51_defucheck(name, ta, tb, tc, op)				\
void name(ta a, tb b, tc c) {						\
    uint8_t	uc;							\
    uint16_t	us;							\
    uint32_t	ui;							\
    uint64_t	ul;							\
    uc = us = ui = ul = b;						\
    if (a op uc != c)	print("error %d\n", __LINE__);			\
    if (a op us != c)	print("error %d\n", __LINE__);			\
    if (a op ui != c)	print("error %d\n", __LINE__);			\
    if (a op ul != c)	print("error %d\n", __LINE__);			\
}
t51_defscheck(t51_slt_ccc, int8_t,  int8_t,  int8_t,  <)
t51_defucheck(t51_ult_ccc, uint8_t, uint8_t, uint8_t, <)
t51_slt_ccc( 1, 2, 1);
t51_slt_ccc( 1, 1, 0);
t51_slt_ccc(-1, 1, 1);
t51_ult_ccc( 1, 2, 1);
t51_ult_ccc( 1, 1, 0);
t51_ult_ccc(-1, 1, 0);
t51_defscheck(t51_slt_sss, int16_t,  int16_t,  int16_t,  <)
t51_defucheck(t51_ult_sss, uint16_t, uint16_t, uint16_t, <)
t51_slt_sss( 1, 2, 1);
t51_slt_sss( 1, 1, 0);
t51_slt_sss(-1, 1, 1);
t51_ult_sss( 1, 2, 1);
t51_ult_sss( 1, 1, 0);
t51_ult_sss(-1, 1, 0);
t51_defscheck(t51_slt_iii, int32_t,  int32_t,  int32_t,  <)
t51_defucheck(t51_ult_iii, uint32_t, uint32_t, uint32_t, <)
t51_slt_iii( 1, 2, 1);
t51_slt_iii( 1, 1, 0);
t51_slt_iii(-1, 1, 1);
t51_ult_iii( 1, 2, 1);
t51_ult_iii( 1, 1, 0);
t51_ult_iii(-1, 1, 0);
t51_defscheck(t51_slt_lll, int64_t,  int64_t,  int64_t,  <)
t51_defucheck(t51_ult_lll, uint64_t, uint64_t, uint64_t, <)
t51_slt_lll( 1, 2, 1);
t51_slt_lll( 1, 1, 0);
t51_slt_lll(-1, 1, 1);
t51_ult_lll( 1, 2, 1);
t51_ult_lll( 1, 1, 0);
t51_ult_lll(-1, 1, 0);
t51_defscheck(t51_slt_fff, float32_t,  float32_t,  float32_t, <)
t51_slt_fff( 1, 2, 1);
t51_slt_fff( 1, 1, 0);
t51_slt_fff(-1, 1, 1);
t51_defscheck(t51_slt_ddd, float64_t,  float64_t,  float64_t, <)
t51_slt_ddd( 1, 2, 1);
t51_slt_ddd( 1, 1, 0);
t51_slt_ddd(-1, 1, 1);
t51_defscheck(t51_slt_vvv, , , , <)
t51_slt_vvv( 1, 2, 1);
t51_slt_vvv( 1, 1, 0);
t51_slt_vvv(-1, 1, 1);
t51_defscheck(t51_sle_ccc, int8_t,  int8_t,  int8_t,  <=)
t51_defucheck(t51_ule_ccc, uint8_t, uint8_t, uint8_t, <=)
t51_sle_ccc( 1, 2, 1);
t51_sle_ccc( 1, 1, 1);
t51_sle_ccc(-1, 1, 1);
t51_ule_ccc( 1, 2, 1);
t51_ule_ccc( 1, 1, 1);
t51_ule_ccc(-1, 1, 0);
t51_defscheck(t51_sle_sss, int16_t,  int16_t,  int16_t,  <=)
t51_defucheck(t51_ule_sss, uint16_t, uint16_t, uint16_t, <=)
t51_sle_sss( 1, 2, 1);
t51_sle_sss( 1, 1, 1);
t51_sle_sss(-1, 1, 1);
t51_ule_sss( 1, 2, 1);
t51_ule_sss( 1, 1, 1);
t51_ule_sss(-1, 1, 0);
t51_defscheck(t51_sle_iii, int32_t,  int32_t,  int32_t,  <=)
t51_defucheck(t51_ule_iii, uint32_t, uint32_t, uint32_t, <=)
t51_sle_iii( 1, 2, 1);
t51_sle_iii( 1, 1, 1);
t51_sle_iii(-1, 1, 1);
t51_ule_iii( 1, 2, 1);
t51_ule_iii( 1, 1, 1);
t51_ule_iii(-1, 1, 0);
t51_defscheck(t51_sle_lll, int64_t,  int64_t,  int64_t,  <=)
t51_defucheck(t51_ule_lll, uint64_t, uint64_t, uint64_t, <=)
t51_sle_lll( 1, 2, 1);
t51_sle_lll( 1, 1, 1);
t51_sle_lll(-1, 1, 1);
t51_ule_lll( 1, 2, 1);
t51_ule_lll( 1, 1, 1);
t51_ule_lll(-1, 1, 0);
t51_defscheck(t51_sle_fff, float32_t,  float32_t,  float32_t, <=)
t51_sle_fff( 1, 2, 1);
t51_sle_fff( 1, 1, 1);
t51_sle_fff(-1, 1, 1);
t51_defscheck(t51_sle_ddd, float64_t,  float64_t,  float64_t, <=)
t51_sle_ddd( 1, 2, 1);
t51_sle_ddd( 1, 1, 1);
t51_sle_ddd(-1, 1, 1);
t51_defscheck(t51_sle_vvv, , , , <=)
t51_sle_vvv( 1, 2, 1);
t51_sle_vvv( 1, 1, 1);
t51_sle_vvv(-1, 1, 1);
t51_defscheck(t51_seq_ccc, int8_t,  int8_t,  int8_t,  ==)
t51_defucheck(t51_ueq_ccc, uint8_t, uint8_t, uint8_t, ==)
t51_seq_ccc( 1, 2, 0);
t51_seq_ccc( 1, 1, 1);
t51_seq_ccc(-1, 1, 0);
t51_ueq_ccc( 1, 2, 0);
t51_ueq_ccc( 1, 1, 1);
t51_ueq_ccc(-1, 1, 0);
t51_defscheck(t51_seq_sss, int16_t,  int16_t,  int16_t,  ==)
t51_defucheck(t51_ueq_sss, uint16_t, uint16_t, uint16_t, ==)
t51_seq_sss( 1, 2, 0);
t51_seq_sss( 1, 1, 1);
t51_seq_sss(-1, 1, 0);
t51_ueq_sss( 1, 2, 0);
t51_ueq_sss( 1, 1, 1);
t51_ueq_sss(-1, 1, 0);
t51_defscheck(t51_seq_iii, int32_t,  int32_t,  int32_t,  ==)
t51_defucheck(t51_ueq_iii, uint32_t, uint32_t, uint32_t, ==)
t51_seq_iii( 1, 2, 0);
t51_seq_iii( 1, 1, 1);
t51_seq_iii(-1, 1, 0);
t51_ueq_iii( 1, 2, 0);
t51_ueq_iii( 1, 1, 1);
t51_ueq_iii(-1, 1, 0);
t51_defscheck(t51_seq_lll, int64_t,  int64_t,  int64_t,  ==)
t51_defucheck(t51_ueq_lll, uint64_t, uint64_t, uint64_t, ==)
t51_seq_lll( 1, 2, 0);
t51_seq_lll( 1, 1, 1);
t51_seq_lll(-1, 1, 0);
t51_ueq_lll( 1, 2, 0);
t51_ueq_lll( 1, 1, 1);
t51_ueq_lll(-1, 1, 0);
t51_defscheck(t51_seq_fff, float32_t,  float32_t,  float32_t, ==)
t51_seq_fff( 1, 2, 0);
t51_seq_fff( 1, 1, 1);
t51_seq_fff(-1, 1, 0);
t51_defscheck(t51_seq_ddd, float64_t,  float64_t,  float64_t, ==)
t51_seq_ddd( 1, 2, 0);
t51_seq_ddd( 1, 1, 1);
t51_seq_ddd(-1, 1, 0);
t51_defscheck(t51_seq_vvv, , , , ==)
t51_seq_vvv( 1, 2, 0);
t51_seq_vvv( 1, 1, 1);
t51_seq_vvv(-1, 1, 0);
t51_defscheck(t51_sge_ccc, int8_t,  int8_t,  int8_t,  >=)
t51_defucheck(t51_uge_ccc, uint8_t, uint8_t, uint8_t, >=)
t51_sge_ccc( 1, 2, 0);
t51_sge_ccc( 1, 1, 1);
t51_sge_ccc(-1, 1, 0);
t51_uge_ccc( 1, 2, 0);
t51_uge_ccc( 1, 1, 1);
t51_uge_ccc(-1, 1, 1);
t51_defscheck(t51_sge_sss, int16_t,  int16_t,  int16_t,  >=)
t51_defucheck(t51_uge_sss, uint16_t, uint16_t, uint16_t, >=)
t51_sge_sss( 1, 2, 0);
t51_sge_sss( 1, 1, 1);
t51_sge_sss(-1, 1, 0);
t51_uge_sss( 1, 2, 0);
t51_uge_sss( 1, 1, 1);
t51_uge_sss(-1, 1, 1);
t51_defscheck(t51_sge_iii, int32_t,  int32_t,  int32_t,  >=)
t51_defucheck(t51_uge_iii, uint32_t, uint32_t, uint32_t, >=)
t51_sge_iii( 1, 2, 0);
t51_sge_iii( 1, 1, 1);
t51_sge_iii(-1, 1, 0);
t51_uge_iii( 1, 2, 0);
t51_uge_iii( 1, 1, 1);
t51_uge_iii(-1, 1, 1);
t51_defscheck(t51_sge_lll, int64_t,  int64_t,  int64_t,  >=)
t51_defucheck(t51_uge_lll, uint64_t, uint64_t, uint64_t, >=)
t51_sge_lll( 1, 2, 0);
t51_sge_lll( 1, 1, 1);
t51_sge_lll(-1, 1, 0);
t51_uge_lll( 1, 2, 0);
t51_uge_lll( 1, 1, 1);
t51_uge_lll(-1, 1, 1);
t51_defscheck(t51_sge_fff, float32_t,  float32_t,  float32_t, >=)
t51_sge_fff( 1, 2, 0);
t51_sge_fff( 1, 1, 1);
t51_sge_fff(-1, 1, 0);
t51_defscheck(t51_sge_ddd, float64_t,  float64_t,  float64_t, >=)
t51_sge_ddd( 1, 2, 0);
t51_sge_ddd( 1, 1, 1);
t51_sge_ddd(-1, 1, 0);
t51_defscheck(t51_sge_vvv, , , , >=)
t51_sge_vvv( 1, 2, 0);
t51_sge_vvv( 1, 1, 1);
t51_sge_vvv(-1, 1, 0);
t51_defscheck(t51_sgt_ccc, int8_t,  int8_t,  int8_t,  >)
t51_defucheck(t51_ugt_ccc, uint8_t, uint8_t, uint8_t, >)
t51_sgt_ccc( 1, 2, 0);
t51_sgt_ccc( 1, 1, 0);
t51_sgt_ccc(-1, 1, 0);
t51_ugt_ccc( 1, 2, 0);
t51_ugt_ccc( 1, 1, 0);
t51_ugt_ccc(-1, 1, 1);
t51_defscheck(t51_sgt_sss, int16_t,  int16_t,  int16_t,  >)
t51_defucheck(t51_ugt_sss, uint16_t, uint16_t, uint16_t, >)
t51_sgt_sss( 1, 2, 0);
t51_sgt_sss( 1, 1, 0);
t51_sgt_sss(-1, 1, 0);
t51_ugt_sss( 1, 2, 0);
t51_ugt_sss( 1, 1, 0);
t51_ugt_sss(-1, 1, 1);
t51_defscheck(t51_sgt_iii, int32_t,  int32_t,  int32_t,  >)
t51_defucheck(t51_ugt_iii, uint32_t, uint32_t, uint32_t, >)
t51_sgt_iii( 1, 2, 0);
t51_sgt_iii( 1, 1, 0);
t51_sgt_iii(-1, 1, 0);
t51_ugt_iii( 1, 2, 0);
t51_ugt_iii( 1, 1, 0);
t51_ugt_iii(-1, 1, 1);
t51_defscheck(t51_sgt_lll, int64_t,  int64_t,  int64_t,  >)
t51_defucheck(t51_ugt_lll, uint64_t, uint64_t, uint64_t, >)
t51_sgt_lll( 1, 2, 0);
t51_sgt_lll( 1, 1, 0);
t51_sgt_lll(-1, 1, 0);
t51_ugt_lll( 1, 2, 0);
t51_ugt_lll( 1, 1, 0);
t51_ugt_lll(-1, 1, 1);
t51_defscheck(t51_sgt_fff, float32_t,  float32_t,  float32_t, >)
t51_sgt_fff( 1, 2, 0);
t51_sgt_fff( 1, 1, 0);
t51_sgt_fff(-1, 1, 0);
t51_defscheck(t51_sgt_ddd, float64_t,  float64_t,  float64_t, >)
t51_sgt_ddd( 1, 2, 0);
t51_sgt_ddd( 1, 1, 0);
t51_sgt_ddd(-1, 1, 0);
t51_defscheck(t51_sgt_vvv, , , , >)
t51_sgt_vvv( 1, 2, 0);
t51_sgt_vvv( 1, 1, 0);
t51_sgt_vvv(-1, 1, 0);
t51_defscheck(t51_sne_ccc, int8_t,  int8_t,  int8_t,  !=)
t51_defucheck(t51_une_ccc, uint8_t, uint8_t, uint8_t, !=)
t51_sne_ccc( 1, 2, 1);
t51_sne_ccc( 1, 1, 0);
t51_sne_ccc(-1, 1, 1);
t51_une_ccc( 1, 2, 1);
t51_une_ccc( 1, 1, 0);
t51_une_ccc(-1, 1, 1);
t51_defscheck(t51_sne_sss, int16_t,  int16_t,  int16_t,  !=)
t51_defucheck(t51_une_sss, uint16_t, uint16_t, uint16_t, !=)
t51_sne_sss( 1, 2, 1);
t51_sne_sss( 1, 1, 0);
t51_sne_sss(-1, 1, 1);
t51_une_sss( 1, 2, 1);
t51_une_sss( 1, 1, 0);
t51_une_sss(-1, 1, 1);
t51_defscheck(t51_sne_iii, int32_t,  int32_t,  int32_t,  !=)
t51_defucheck(t51_une_iii, uint32_t, uint32_t, uint32_t, !=)
t51_sne_iii( 1, 2, 1);
t51_sne_iii( 1, 1, 0);
t51_sne_iii(-1, 1, 1);
t51_une_iii( 1, 2, 1);
t51_une_iii( 1, 1, 0);
t51_une_iii(-1, 1, 1);
t51_defscheck(t51_sne_lll, int64_t,  int64_t,  int64_t,  !=)
t51_defucheck(t51_une_lll, uint64_t, uint64_t, uint64_t, !=)
t51_sne_lll( 1, 2, 1);
t51_sne_lll( 1, 1, 0);
t51_sne_lll(-1, 1, 1);
t51_une_lll( 1, 2, 1);
t51_une_lll( 1, 1, 0);
t51_une_lll(-1, 1, 1);
t51_defscheck(t51_sne_fff, float32_t,  float32_t,  float32_t, !=)
t51_sne_fff( 1, 2, 1);
t51_sne_fff( 1, 1, 0);
t51_sne_fff(-1, 1, 1);
t51_defscheck(t51_sne_ddd, float64_t,  float64_t,  float64_t, !=)
t51_sne_ddd( 1, 2, 1);
t51_sne_ddd( 1, 1, 0);
t51_sne_ddd(-1, 1, 1);
t51_defscheck(t51_sne_vvv, , , , !=)
t51_sne_vvv( 1, 2, 1);
t51_sne_vvv( 1, 1, 0);
t51_sne_vvv(-1, 1, 1);
t51_defscheck(t51_sadd_ccc, int8_t,  int8_t,  int8_t,  +)
t51_defucheck(t51_uadd_ccc, uint8_t, uint8_t, uint16_t, +)
t51_sadd_ccc( 1, 2, 3);
t51_sadd_ccc( 1, 1, 2);
t51_sadd_ccc(-1, 1, 0);
t51_uadd_ccc( 1, 2, 3);
t51_uadd_ccc( 1, 1, 2);
t51_uadd_ccc(-1, 1, 256);
t51_defscheck(t51_sadd_sss, int16_t,  int16_t,  int16_t,  +)
t51_defucheck(t51_uadd_sss, uint16_t, uint16_t, uint32_t, +)
t51_sadd_sss( 1, 2, 3);
t51_sadd_sss( 1, 1, 2);
t51_sadd_sss(-1, 1, 0);
t51_uadd_sss( 1, 2, 3);
t51_uadd_sss( 1, 1, 2);
t51_uadd_sss(-1, 1, 65536);
t51_defscheck(t51_sadd_iii, int32_t,  int32_t,  int32_t,  +)
t51_defucheck(t51_uadd_iii, uint32_t, uint32_t, uint64_t, +)
t51_sadd_iii( 1, 2, 3);
t51_sadd_iii( 1, 1, 2);
t51_sadd_iii(-1, 1, 0);
t51_uadd_iii( 1, 2, 3);
t51_uadd_iii( 1, 1, 2);
t51_uadd_iii(-1, 1, 4294967296);
t51_defscheck(t51_sadd_lll, int64_t,  int64_t,  int64_t,  +)
t51_defucheck(t51_uadd_lll, uint64_t, uint64_t, , +)
t51_sadd_lll( 1, 2, 3);
t51_sadd_lll( 1, 1, 2);
t51_sadd_lll(-1, 1, 0);
t51_uadd_lll( 1, 2, 3);
t51_uadd_lll( 1, 1, 2);
t51_uadd_lll(-1, 1, 18446744073709551616);
t51_defscheck(t51_sadd_fff, float32_t,  float32_t,  float32_t, +)
t51_sadd_fff( 1, 2, 3);
t51_sadd_fff( 1, 1, 2);
t51_sadd_fff(-1, 1, 0);
t51_defscheck(t51_sadd_ddd, float64_t,  float64_t,  float64_t, +)
t51_sadd_ddd( 1, 2, 3);
t51_sadd_ddd( 1, 1, 2);
t51_sadd_ddd(-1, 1, 0);
t51_defscheck(t51_sadd_vvv, , , , +)
t51_sadd_vvv( 1, 2, 3);
t51_sadd_vvv( 1, 1, 2);
t51_sadd_vvv(-1, 1, 0);
t51_defscheck(t51_ssub_ccc, int8_t,  int8_t,  int8_t,  -)
t51_defucheck(t51_usub_ccc, uint8_t, uint8_t, , -)
t51_ssub_ccc( 1, 2, -1);
t51_ssub_ccc( 1, 1,  0);
t51_ssub_ccc(-1, 1, -2);
t51_usub_ccc( 1, 2, -1);
t51_usub_ccc( 1, 1,  0);
t51_usub_ccc(-1, 1,  254);
t51_defscheck(t51_ssub_sss, int16_t,  int16_t,  int16_t,  -)
t51_defucheck(t51_usub_sss, uint16_t, uint16_t, , -)
t51_ssub_sss( 1, 2, -1);
t51_ssub_sss( 1, 1,  0);
t51_ssub_sss(-1, 1, -2);
t51_usub_sss( 1, 2, -1);
t51_usub_sss( 1, 1,  0);
t51_usub_sss(-1, 1,  65534);
t51_defscheck(t51_ssub_iii, int32_t,  int32_t,  int32_t,  -)
t51_defucheck(t51_usub_iii, uint32_t, uint32_t, , -)
t51_ssub_iii( 1, 2, -1);
t51_ssub_iii( 1, 1,  0);
t51_ssub_iii(-1, 1, -2);
t51_usub_iii( 1, 2, -1);
t51_usub_iii( 1, 1,  0);
t51_usub_iii(-1, 1,  4294967294);
t51_defscheck(t51_ssub_lll, int64_t,  int64_t,  int64_t,  -)
t51_defucheck(t51_usub_lll, uint64_t, , , -)
t51_ssub_lll( 1, 2, -1);
t51_ssub_lll( 1, 1,  0);
t51_ssub_lll(-1, 1, -2);
t51_usub_lll( 1, 2, -1);
t51_usub_lll( 1, 1,  0);
t51_usub_lll(-1, 1,  18446744073709551614);
t51_defscheck(t51_ssub_fff, float32_t,  float32_t,  float32_t, -)
t51_ssub_fff( 1, 2, -1);
t51_ssub_fff( 1, 1,  0);
t51_ssub_fff(-1, 1, -2);
t51_defscheck(t51_ssub_ddd, float64_t,  float64_t,  float64_t, -)
t51_ssub_ddd( 1, 2, -1);
t51_ssub_ddd( 1, 1,  0);
t51_ssub_ddd(-1, 1, -2);
t51_defscheck(t51_ssub_vvv, , , , -)
t51_ssub_vvv( 1, 2, -1);
t51_ssub_vvv( 1, 1,  0);
t51_ssub_vvv(-1, 1, -2);

/* test 52 - generic crafted special conditions in jit generation */
void t52_0(void) {
    uint64_t	u;
    for (u = 0x7ffffffffffffff0; u < 0x8000000000010000.0; u++)
	;
    if (u != 0x8000000000010000.0)
	print("error %d\n", __LINE__);
}
t52_0();
class t52_c_t {
    int8_t	c;	uint8_t		uc;
    int16_t	s;	uint16_t	us;
    int32_t	i;	uint32_t	ui;
    int64_t	l;	uint64_t	ul;
    float32_t	f;	float64_t	d;
    auto	v;
    int8_t c_c_I()	{ return c++; }
    int8_t c_uc_I()	{ return uc++; }
    int16_t s_s_I()	{ return s++; }
    int16_t s_us_I()	{ return us++; }
    int32_t i_i_I()	{ return i++; }
    int32_t i_ui_I()	{ return ui++; }
    int64_t l_l_I()	{ return l++; }
    int64_t l_ul_I()	{ return ul++; }
    float32_t f_f_I()	{ return f++; }
    float64_t d_d_I()	{ return d++; }
    auto v_v_I()	{ return v++; }
    int8_t c_c_D()	{ return c--; }
    int8_t c_uc_D()	{ return uc--; }
    int16_t s_s_D()	{ return s--; }
    int16_t s_us_D()	{ return us--; }
    int32_t i_i_D()	{ return i--; }
    int32_t i_ui_D()	{ return ui--; }
    int64_t l_l_D()	{ return l--; }
    int64_t l_ul_D()	{ return ul--; }
    float32_t f_f_D()	{ return f--; }
    float64_t d_d_D()	{ return d--; }
    auto v_v_D()	{ return v--; }
    int8_t c_I_c()	{ return ++c; }
    int8_t c_I_uc()	{ return ++uc; }
    int16_t s_I_s()	{ return ++s; }
    int16_t s_I_us()	{ return ++us; }
    int32_t i_I_i()	{ return ++i; }
    int32_t i_I_ui()	{ return ++ui; }
    int64_t l_I_l()	{ return ++l; }
    int64_t l_I_ul()	{ return ++ul; }
    float32_t f_I_f()	{ return ++f; }
    float64_t d_I_d()	{ return ++d; }
    auto v_I_v()	{ return ++v; }
    int8_t c_D_c()	{ return --c; }
    int8_t c_D_uc()	{ return --uc; }
    int16_t s_D_s()	{ return --s; }
    int16_t s_D_us()	{ return --us; }
    int32_t i_D_i()	{ return --i; }
    int32_t i_D_ui()	{ return --ui; }
    int64_t l_D_l()	{ return --l; }
    int64_t l_D_ul()	{ return --ul; }
    float32_t f_D_f()	{ return --f; }
    float64_t d_D_d()	{ return --d; }
    auto v_D_v()	{ return --v; }
    void c_A_c(int8_t a)	{ c += a; }
    void c_A_uc(uint8_t a)	{ c += a; }
    void c_A_s(int16_t a)	{ c += a; }
    void c_A_us(uint16_t a)	{ c += a; }
    void c_A_i(int32_t a)	{ c += a; }
    void c_A_ui(uint32_t a)	{ c += a; }
    void c_A_l(int64_t a)	{ c += a; }
    void c_A_ul(uint64_t a)	{ c += a; }
    void c_A_f(float32_t a)	{ c += a; }
    void c_A_d(float64_t a)	{ c += a; }
    void c_A_v(a)		{ c += a; }
    void uc_A_c(int8_t a)	{ uc += a; }
    void uc_A_uc(uint8_t a)	{ uc += a; }
    void uc_A_s(int16_t a)	{ uc += a; }
    void uc_A_us(uint16_t a)	{ uc += a; }
    void uc_A_i(int32_t a)	{ uc += a; }
    void uc_A_ui(uint32_t a)	{ uc += a; }
    void uc_A_l(int64_t a)	{ uc += a; }
    void uc_A_ul(uint64_t a)	{ uc += a; }
    void uc_A_f(float32_t a)	{ uc += a; }
    void uc_A_d(float64_t a)	{ uc += a; }
    void uc_A_v(a)		{ uc += a; }
    void s_A_c(int8_t a)	{ s += a; }
    void s_A_uc(uint8_t a)	{ s += a; }
    void s_A_s(int16_t a)	{ s += a; }
    void s_A_us(uint16_t a)	{ s += a; }
    void s_A_i(int32_t a)	{ s += a; }
    void s_A_ui(uint32_t a)	{ s += a; }
    void s_A_l(int64_t a)	{ s += a; }
    void s_A_ul(uint64_t a)	{ s += a; }
    void s_A_f(float32_t a)	{ s += a; }
    void s_A_d(float64_t a)	{ s += a; }
    void s_A_v(a)		{ s += a; }
    void us_A_c(int8_t a)	{ us += a; }
    void us_A_uc(uint8_t a)	{ us += a; }
    void us_A_s(int16_t a)	{ us += a; }
    void us_A_us(uint16_t a)	{ us += a; }
    void us_A_i(int32_t a)	{ us += a; }
    void us_A_ui(uint32_t a)	{ us += a; }
    void us_A_l(int64_t a)	{ us += a; }
    void us_A_ul(uint64_t a)	{ us += a; }
    void us_A_f(float32_t a)	{ us += a; }
    void us_A_d(float64_t a)	{ us += a; }
    void us_A_v(a)		{ us += a; }
    void i_A_c(int8_t a)	{ i += a; }
    void i_A_uc(uint8_t a)	{ i += a; }
    void i_A_s(int16_t a)	{ i += a; }
    void i_A_us(uint16_t a)	{ i += a; }
    void i_A_i(int32_t a)	{ i += a; }
    void i_A_ui(uint32_t a)	{ i += a; }
    void i_A_l(int64_t a)	{ i += a; }
    void i_A_ul(uint64_t a)	{ i += a; }
    void i_A_f(float32_t a)	{ i += a; }
    void i_A_d(float64_t a)	{ i += a; }
    void i_A_v(a)		{ i += a; }
    void ui_A_c(int8_t a)	{ ui += a; }
    void ui_A_uc(uint8_t a)	{ ui += a; }
    void ui_A_s(int16_t a)	{ ui += a; }
    void ui_A_us(uint16_t a)	{ ui += a; }
    void ui_A_i(int32_t a)	{ ui += a; }
    void ui_A_ui(uint32_t a)	{ ui += a; }
    void ui_A_l(int64_t a)	{ ui += a; }
    void ui_A_ul(uint64_t a)	{ ui += a; }
    void ui_A_f(float32_t a)	{ ui += a; }
    void ui_A_d(float64_t a)	{ ui += a; }
    void ui_A_v(a)		{ ui += a; }
    void l_S_c(int8_t a)	{ l -= a; }
    void l_S_uc(uint8_t a)	{ l -= a; }
    void l_S_s(int16_t a)	{ l -= a; }
    void l_S_us(uint16_t a)	{ l -= a; }
    void l_S_i(int32_t a)	{ l -= a; }
    void l_S_ui(uint32_t a)	{ l -= a; }
    void l_S_l(int64_t a)	{ l -= a; }
    void l_S_ul(uint64_t a)	{ l -= a; }
    void l_S_f(float32_t a)	{ l -= a; }
    void l_S_d(float64_t a)	{ l -= a; }
    void l_S_v(a)		{ l -= a; }
    void ul_S_c(int8_t a)	{ ul -= a; }
    void ul_S_uc(uint8_t a)	{ ul -= a; }
    void ul_S_s(int16_t a)	{ ul -= a; }
    void ul_S_us(uint16_t a)	{ ul -= a; }
    void ul_S_i(int32_t a)	{ ul -= a; }
    void ul_S_ui(uint32_t a)	{ ul -= a; }
    void ul_S_l(int64_t a)	{ ul -= a; }
    void ul_S_ul(uint64_t a)	{ ul -= a; }
    void ul_S_f(float32_t a)	{ ul -= a; }
    void ul_S_d(float64_t a)	{ ul -= a; }
    void ul_S_v(a)		{ ul -= a; }
    void f_S_c(int8_t a)	{ f -= a; }
    void f_S_uc(uint8_t a)	{ f -= a; }
    void f_S_s(int16_t a)	{ f -= a; }
    void f_S_us(uint16_t a)	{ f -= a; }
    void f_S_i(int32_t a)	{ f -= a; }
    void f_S_ui(uint32_t a)	{ f -= a; }
    void f_S_l(int64_t a)	{ f -= a; }
    void f_S_ul(uint64_t a)	{ f -= a; }
    void f_S_f(float32_t a)	{ f -= a; }
    void f_S_d(float64_t a)	{ f -= a; }
    void f_S_v(a)		{ f -= a; }
    void d_S_c(int8_t a)	{ d -= a; }
    void d_S_uc(uint8_t a)	{ d -= a; }
    void d_S_s(int16_t a)	{ d -= a; }
    void d_S_us(uint16_t a)	{ d -= a; }
    void d_S_i(int32_t a)	{ d -= a; }
    void d_S_ui(uint32_t a)	{ d -= a; }
    void d_S_l(int64_t a)	{ d -= a; }
    void d_S_ul(uint64_t a)	{ d -= a; }
    void d_S_f(float32_t a)	{ d -= a; }
    void d_S_d(float64_t a)	{ d -= a; }
    void d_S_v(a)		{ d -= a; }
    void v_S_c(int8_t a)	{ v -= a; }
    void v_S_uc(uint8_t a)	{ v -= a; }
    void v_S_s(int16_t a)	{ v -= a; }
    void v_S_us(uint16_t a)	{ v -= a; }
    void v_S_i(int32_t a)	{ v -= a; }
    void v_S_ui(uint32_t a)	{ v -= a; }
    void v_S_l(int64_t a)	{ v -= a; }
    void v_S_ul(uint64_t a)	{ v -= a; }
    void v_S_f(float32_t a)	{ v -= a; }
    void v_S_d(float64_t a)	{ v -= a; }
    void v_S_v(a)		{ v -= a; }
    void reset()	{ c = uc = s = us = i = ui = l = ul = f = d = v = 0; }
    void t0() {
	/* assuming first call (basically to have v as null) */
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
	if (c_c_I() != 0.0 || c_uc_I() != 0 ||
	    s_s_I() != 0 || s_us_I() != 0.0 ||
	    i_i_I() != 0.0 || i_ui_I() != 0 ||
	    l_l_I() != 0 || l_ul_I() != 0.0 ||
	    f_f_I() != 0.0 || d_d_I() != 0 ||
	    v_v_I() != 0)
	    print("error %d\n", __LINE__);
	if (c != 1 || uc != 1.0 ||
	    s != 1.0 || us != 1 ||
	    i != 1 || ui != 1.0 ||
	    l != 1.0 || ul != 1 ||
	    f != 1 || d != 1.0 ||
	    v != 1.0)
	    print("error %d\n", __LINE__);
	if (c_D_c() != 0 || c_D_uc() != 0.0 ||
	    s_D_s() != 0.0 || s_D_us() != 0 ||
	    i_D_i() != 0 || i_D_ui() != 0.0 ||
	    l_D_l() != 0.0 || l_D_ul() != 0 ||
	    f_D_f() != 0 || d_D_d() != 0.0 ||
	    v_D_v() != 0)
	    print("error %d\n", __LINE__);
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
    }
    void t1() {
	reset();
	if (c_c_I() != 0.0 || c_uc_I() != 0 ||
	    s_s_I() != 0 || s_us_I() != 0.0 ||
	    i_i_I() != 0.0 || i_ui_I() != 0 ||
	    l_l_I() != 0 || l_ul_I() != 0.0 ||
	    f_f_I() != 0.0 || d_d_I() != 0 ||
	    v_v_I() != 0)
	    print("error %d\n", __LINE__);
	if (c != 1 || uc != 1.0 ||
	    s != 1.0 || us != 1 ||
	    i != 1 || ui != 1.0 ||
	    l != 1.0 || ul != 1 ||
	    f != 1 || d != 1.0 ||
	    v != 1.0)
	    print("error %d\n", __LINE__);
	if (c_D_c() != 0 || c_D_uc() != 0.0 ||
	    s_D_s() != 0.0 || s_D_us() != 0 ||
	    i_D_i() != 0 || i_D_ui() != 0.0 ||
	    l_D_l() != 0.0 || l_D_ul() != 0 ||
	    f_D_f() != 0 || d_D_d() != 0.0 ||
	    v_D_v() != 0)
	    print("error %d\n", __LINE__);
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
    }
    void t2() {
	reset();
	ul = 0x7fffffffffffffff;
	if (l_ul_I() != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
	if (l_ul_I() != -0x8000000000000000)	print("error %d\n", __LINE__);
	if (l_ul_I() != -0x7fffffffffffffff)	print("error %d\n", __LINE__);
	if (l_D_ul() != -0x7fffffffffffffff)	print("error %d\n", __LINE__);
	if (l_D_ul() != -0x8000000000000000)	print("error %d\n", __LINE__);
	if (ul != 0x8000000000000000)		print("error %d\n", __LINE__);
    }
    void t3() {
	reset();
	if (c_c_D() != 0.0 || c_uc_D() != 0 ||
	    s_s_D() != 0 || s_us_D() != 0.0 ||
	    i_i_D() != 0.0 || i_ui_D() != 0 ||
	    l_l_D() != 0 || l_ul_D() != 0.0 ||
	    f_f_D() != 0.0 || d_d_D() != 0 ||
	    v_v_D() != 0)
	    print("error %d\n", __LINE__);
	if (c != -1 || uc != 0xff.0 ||
	    s != -1.0 || us != 0xffff ||
	    i != -1 || ui != 0xffffffff.0 ||
	    l != -1.0 || ul != 0xffffffffffffffff ||
	    f != -1 || d != -1.0 ||
	    v != -1.0)
	    print("error %d\n", __LINE__);
	if (c_I_c() != 0 || c_I_uc() != 0.0 ||
	    s_I_s() != 0.0 || s_I_us() != 0 ||
	    i_I_i() != 0 || i_I_ui() != 0.0 ||
	    l_I_l() != 0.0 || l_I_ul() != 0 ||
	    f_I_f() != 0 || d_I_d() != 0.0 ||
	    v_I_v() != 0)
	    print("error %d\n", __LINE__);
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
    }
    void t4() {
	int8_t		xc;	uint8_t		xuc;
	int16_t		xs;	uint16_t	xus;
	int32_t		xi;	uint32_t	xui;
	int64_t		xl;	uint64_t	xul;
	float32_t	xf;	float64_t	xd;
	auto		xv;
	reset();
	xc = c++;	xuc = uc++;	xs = s++;	xus = us++;
	xi = i++;	xui = ui++;	xl = l++;	xul = ul++;
	xf = f++;	xd = d++;	xv = v++;
	if (xc != 0 || xuc != 0.0 ||
	    xs != 0.0 || xus != 0 ||
	    xi != 0 || xui != 0.0 ||
	    xl != 0.0 || xul != 0 ||
	    xf != 0 || xd != 0.0 ||
	    xv != 0.0)
	    print("error %d\n", __LINE__);
	if (c != 1 || uc != 1.0 ||
	    s != 1.0 || us != 1 ||
	    i != 1 || ui != 1.0 ||
	    l != 1.0 || ul != 1 ||
	    f != 1 || d != 1.0 ||
	    v != 1.0)
	    print("error %d\n", __LINE__);
	xc = c--;	xuc = uc--;	xs = s--;	xus = us--;
	xi = i--;	xui = ui--;	xl = l--;	xul = ul--;
	xf = f--;	xd = d--;	xv = v--;
	if (xc != 1.0 || xuc != 1 ||
	    xs != 1 || xus != 1.0 ||
	    xi != 1.0 || xui != 1 ||
	    xl != 1 || xul != 1.0 ||
	    xf != 1.0 || xd != 1 ||
	    xv != 1)
	    print("error %d\n", __LINE__);
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
	xc = ++c;	xuc = ++uc;	xs = ++s;	xus = ++us;
	xi = ++i;	xui = ++ui;	xl = ++l;	xul = ++ul;
	xf = ++f;	xd = ++d;	xv = ++v;
	if (xc != c || xuc != uc ||
	    xs != s || xus != us ||
	    xi != i || xui != ui ||
	    xl != l || xul != ul ||
	    xf != f || xd != d ||
	    xv != v)
	    print("error %d\n", __LINE__);
	c = --xv;	uc = --xd;	s = --xf;	us = --xul;
	i = --xl;	ui = --xui;	l = --xi;	ul = --xus;
	f = --xs;	d = --xuc;	v = --xc;
	if (c != 0.0 || uc != 0 ||
	    s != 0 || us != 0.0 ||
	    i != 0.0 || ui != 0 ||
	    l != 0 || ul != 0.0 ||
	    f != 0.0 || d != 0 ||
	    v != 0)
	    print("error %d\n", __LINE__);
    }
    /* float comparisons may vary due to conversion... */
    void t5() {
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x7f;
	c_A_c(c);
	if (c != -0x02)		print("error %d\n", __LINE__);
	c_A_uc(uc);
	if (c !=  0x7d)		print("error %d\n", __LINE__);
	c_A_s(s);
	if (c != -0x04)		print("error %d\n", __LINE__);
	c_A_us(us);
	if (c !=  0x7b)		print("error %d\n", __LINE__);
	c_A_i(i);
	if (c != -0x06)		print("error %d\n", __LINE__);
	c_A_ui(ui);
	if (c !=  0x79)		print("error %d\n", __LINE__);
	c_A_l(l);
	if (c != -0x08)		print("error %d\n", __LINE__);
	c_A_ul(ul);
	if (c !=  0x77)		print("error %d\n", __LINE__);
	c_A_f(f);
	if (c != -0x0a)		print("error %d\n", __LINE__);
	c_A_d(d);
	if (c !=  0x75)		print("error %d\n", __LINE__);
	c_A_v(v);
	if (c != -0x0c)		print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x81;
	uc_A_c(c);
	if (uc != 0x02)		print("error %d\n", __LINE__);
	uc_A_uc(uc);
	if (uc != 0x04)		print("error %d\n", __LINE__);
	uc_A_s(s);
	if (uc != 0x85)		print("error %d\n", __LINE__);
	uc_A_us(us);
	if (uc != 0x06)		print("error %d\n", __LINE__);
	uc_A_i(i);
	if (uc != 0x87)		print("error %d\n", __LINE__);
	uc_A_ui(ui);
	if (uc != 0x08)		print("error %d\n", __LINE__);
	uc_A_l(l);
	if (uc != 0x89)		print("error %d\n", __LINE__);
	uc_A_ul(ul);
	if (uc != 0x0a)		print("error %d\n", __LINE__);
	uc_A_f(f);
	if (uc != 0x8b)		print("error %d\n", __LINE__);
	uc_A_d(d);
	if (uc != 0x0c)		print("error %d\n", __LINE__);
	uc_A_v(v);
	if (uc != 0x8d)		print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x8001;
	s_A_c(c);
	if (s != -0x7ffe)		print("error %d\n", __LINE__);
	s_A_uc(uc);
	if (s != -0x7ffd)		print("error %d\n", __LINE__);
	s_A_s(s);
	if (s !=  0x0006)		print("error %d\n", __LINE__);
	s_A_us(us);
	if (s != -0x7ff9)		print("error %d\n", __LINE__);
	s_A_i(i);
	if (s !=  0x0008)		print("error %d\n", __LINE__);
	s_A_ui(ui);
	if (s != -0x7ff7)		print("error %d\n", __LINE__);
	s_A_l(l);
	if (s !=  0x000a)		print("error %d\n", __LINE__);
	s_A_ul(ul);
	if (s != -0x7ff5)		print("error %d\n", __LINE__);
	s_A_f(f);
	if (s !=  0x000c)		print("error %d\n", __LINE__);
	s_A_d(d);
	if (s != -0x7ff3)		print("error %d\n", __LINE__);
	s_A_v(v);  if (s !=  0x000e)	print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x7fff;
	us_A_c(c);
	if (us != 0x7ffe)		print("error %d\n", __LINE__);
	us_A_uc(uc);
	if (us != 0x80fd)		print("error %d\n", __LINE__);
	us_A_s(s);
	if (us != 0x00fc)		print("error %d\n", __LINE__);
	us_A_us(us);
	if (us != 0x01f8)		print("error %d\n", __LINE__);
	us_A_i(i);
	if (us != 0x81f7)		print("error %d\n", __LINE__);
	us_A_ui(ui);
	if (us != 0x01f6)		print("error %d\n", __LINE__);
	us_A_l(l);
	if (us != 0x81f5)		print("error %d\n", __LINE__);
	us_A_ul(ul);
	if (us != 0x01f4)		print("error %d\n", __LINE__);
	us_A_f(f);
	if (us != 0x81f3)		print("error %d\n", __LINE__);
	us_A_d(d);
	if (us != 0x01f2)		print("error %d\n", __LINE__);
	us_A_v(v);
	if (us != 0x81f1)		print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0xa5a5a5a5;
	i_A_c(c);
	if (i != -0x5a5a5ab6)		print("error %d\n", __LINE__);
	i_A_uc(uc);
	if (i != -0x5a5a5a11)		print("error %d\n", __LINE__);
	i_A_s(s);
	if (i != -0x5a5ab46c)		print("error %d\n", __LINE__);
	i_A_us(us);
	if (i != -0x5a5a0ec7)		print("error %d\n", __LINE__);
	i_A_i(i);
	if (i !=  0x4b4be272)		print("error %d\n", __LINE__);
	i_A_ui(ui);
	if (i != -0x0f0e77e9)		print("error %d\n", __LINE__);
	i_A_l(l);
	if (i != -0x6968d244)		print("error %d\n", __LINE__);
	i_A_ul(ul);
	if (i !=  0x3c3cd361)		print("error %d\n", __LINE__);
	/* truncate overflow */
	if (i_A_f(f), i == -0x80000000) {
	    i_A_d(d);
	    if (i !=  0x25a5a5a5)	print("error %d\n", __LINE__);
	    i_A_v(v);
	    if (i != -0x34b4b4b6)	print("error %d\n", __LINE__);
	}
	else {
	    if (i != 0x7fffffff)	print("error %d\n", __LINE__);
	    i_A_d(d);
	    if (i !=  0x7fffffff)	print("error %d\n", __LINE__);
	    i_A_v(v);
	    if (i !=  0x25a5a5a4)	print("error %d\n", __LINE__);
	}
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x80007ffe;
	ui_A_c(c);
	if (ui != 0x80007ffc)		print("error %d\n", __LINE__);
	ui_A_uc(uc);
	if (ui != 0x800080fa)		print("error %d\n", __LINE__);
	ui_A_s(s);
	if (ui != 0x800100f8)		print("error %d\n", __LINE__);
	ui_A_us(us);
	if (ui != 0x800180f6)		print("error %d\n", __LINE__);
	ui_A_i(i);
	if (ui != 0x000200f4)		print("error %d\n", __LINE__);
	ui_A_ui(ui);
	if (ui != 0x000401e8)		print("error %d\n", __LINE__);
	ui_A_l(l);
	if (ui != 0x800481e6)		print("error %d\n", __LINE__);
	ui_A_ul(ul);
	if (ui != 0x000501e4)		print("error %d\n", __LINE__);
	/* truncate overflow */
	if (ui_A_f(f), ui == 0x80000000) {
	    ui_A_d(d);
	    if (ui != 0x80000000)	print("error %d\n", __LINE__);
	    ui_A_v(v);
	    if (ui != 0x00007ffe)	print("error %d\n", __LINE__);
	}
	else {
	    if (ui != 0x7fffffff)	print("error %d\n", __LINE__);
	    ui_A_d(d);
	    if (ui != 0x7fffffff)	print("error %d\n", __LINE__);
	    ui_A_v(v);
	    if (ui != 0x00007ffd)	print("error %d\n", __LINE__);
	}
	c = uc = s = us = i = ui = l = ul = f = d = v = 0xfffffffffffffffe;
	l_S_c(c);
	if (l !=  0x0000000000000000)	print("error %d\n", __LINE__);
	l_S_uc(uc);
	if (l != -0x00000000000000fe)	print("error %d\n", __LINE__);
	l_S_s(s);
	if (l != -0x00000000000000fc)	print("error %d\n", __LINE__);
	l_S_us(us);
	if (l != -0x00000000000100fa)	print("error %d\n", __LINE__);
	l_S_i(i);
	if (l != -0x00000000000100f8)	print("error %d\n", __LINE__);
	l_S_ui(ui);
	if (l != -0x00000001000100f6)	print("error %d\n", __LINE__);
	l_S_l(l);
	if (l !=  0x0000000000000000)	print("error %d\n", __LINE__);
	l_S_ul(ul);
	if (l !=  0x0000000000000002)	print("error %d\n", __LINE__);
	if (l_S_f(f), l == -0x8000000000000000) {
	    l_S_d(d);
	    if (l != -0x8000000000000000)print("error %d\n", __LINE__);
	    l_S_v(v);
	    if (l != -0x7ffffffffffffffe)print("error %d\n", __LINE__);
	}
	else {
	    if (l != 0x0000000000000001)print("error %d\n", __LINE__);
	    l_S_d(d);
	    if (l != 0x0000000000000800)print("error %d\n", __LINE__);
	    l_S_v(v);
	    if (l != 0x0000000000000802)print("error %d\n", __LINE__);
	}
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x8000000000000001;
	ul_S_c(c);
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_S_uc(uc);
	if (ul != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
	ul_S_s(s);
	if (ul != 0x7ffffffffffffffe)	print("error %d\n", __LINE__);
	ul_S_us(us);
	if (ul != 0x7ffffffffffffffd)	print("error %d\n", __LINE__);
	ul_S_i(i);
	if (ul != 0x7ffffffffffffffc)	print("error %d\n", __LINE__);
	ul_S_ui(ui);
	if (ul != 0x7ffffffffffffffb)	print("error %d\n", __LINE__);
	ul_S_l(l);
	if (ul != 0xfffffffffffffffa)	print("error %d\n", __LINE__);
	ul_S_ul(ul);
	if (ul != 0x0000000000000000)	print("error %d\n", __LINE__);
	ul_S_f(f);
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_S_d(d);
	if (ul != 0x0000000000000000)	print("error %d\n", __LINE__);
	ul_S_v(v);
	if (ul != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x800000.0;
	f_S_c(c);
	if (f !=  0x0800000.0)		print("error %d\n", __LINE__);
	f_S_uc(uc);
	if (f !=  0x0800000.0)		print("error %d\n", __LINE__);
	f_S_s(s);
	if (f !=  0x0800000.0)		print("error %d\n", __LINE__);
	f_S_us(us);
	if (f !=  0x0800000.0)		print("error %d\n", __LINE__);
	f_S_i(i);
	if (f != -0x0000000.0)		print("error %d\n", __LINE__);
	f_S_ui(ui);
	if (f != -0x0800000.0)		print("error %d\n", __LINE__);
	f_S_l(l);
	if (f != -0x1000000.0)		print("error %d\n", __LINE__);
	f_S_ul(ul);
	if (f != -0x1800000.0)		print("error %d\n", __LINE__);
	f_S_f(f);
	if (f !=  0x0000000.0)		print("error %d\n", __LINE__);
	f_S_d(d);
	if (f != -0x0800000.0)		print("error %d\n", __LINE__);
	f_S_v(v);
	if (f != -0x1000000.0)		print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0xffff.0;
	d_S_c(c);
	if (d !=  0x10000.0)		print("error %d\n", __LINE__);
	d_S_uc(uc);
	if (d !=  0x0ff01.0)		print("error %d\n", __LINE__);
	d_S_s(s);
	if (d !=  0x0ff02.0)		print("error %d\n", __LINE__);
	d_S_us(us);
	if (d != -0x000fd.0)		print("error %d\n", __LINE__);
	d_S_i(i);
	if (d != -0x100fc.0)		print("error %d\n", __LINE__);
	d_S_ui(ui);
	if (d != -0x200fb.0)		print("error %d\n", __LINE__);
	d_S_l(l);
	if (d != -0x300fa.0)		print("error %d\n", __LINE__);
	d_S_ul(ul);
	if (d != -0x400f9.0)		print("error %d\n", __LINE__);
	d_S_f(f);
	if (d != -0x500f8.0)		print("error %d\n", __LINE__);
	d_S_d(d);
	if (d !=  0x00000.0)		print("error %d\n", __LINE__);
	d_S_v(v);
	if (d != -0x0ffff.0)		print("error %d\n", __LINE__);
	c = uc = s = us = i = ui = l = ul = f = d = v = 0x7fffffffffffffff;
	v_S_c(c);
	if (v !=  0x8000000000000000)	print("error %d\n", __LINE__);
	v_S_uc(uc);
	if (v !=  0x7fffffffffffff01)	print("error %d\n", __LINE__);
	v_S_s(s);
	if (v !=  0x7fffffffffffff02)	print("error %d\n", __LINE__);
	v_S_us(us);
	if (v !=  0x7ffffffffffeff03)	print("error %d\n", __LINE__);
	v_S_i(i);
	if (v !=  0x7ffffffffffeff04)	print("error %d\n", __LINE__);
	v_S_ui(ui);
	if (v !=  0x7ffffffefffeff05)	print("error %d\n", __LINE__);
	v_S_l(l);
	if (v != -0x00000001000100fa)	print("error %d\n", __LINE__);
	v_S_ul(ul);
	if (v != -0x80000001000100f9)	print("error %d\n", __LINE__);
	v_S_f(f);
	if (v != -0x10000000100010000.0 || typeof(v) != typeof(0.0))
	    print("error %d\n", __LINE__);
	v_S_d(d);
	if (v != -0x18000000100010000.0)print("error %d\n", __LINE__);
	v_S_v(v);
	if (v !=  0.0)			print("error %d\n", __LINE__);
    }
} t52_class = {};
t52_class.t0();
t52_class.t1();
t52_class.t2();
t52_class.t3();
t52_class.t4();
t52_class.t5();
/* Equivalent of previous tests using global variables. */
int8_t		t52_c;	uint8_t		t52_uc;
int16_t		t52_s;	uint16_t	t52_us;
int32_t		t52_i;	uint32_t	t52_ui;
int64_t		t52_l;	uint64_t	t52_ul;
float32_t	t52_f;	float64_t	t52_d;
auto		t52_v;
int32_t		t52_gi;	uint32_t	t52_gui;
int64_t		t52_gl;	uint64_t	t52_gul;
float32_t	t52_gf;	float64_t	t52_gd;
auto		t52_gv;
for (t52_ul = 0x7ffffffffffffff0; t52_ul < 0x8000000000010000.0; t52_ul++)
    ;
if (t52_ul != 0x8000000000010000.0)		print("error %d\n", __LINE__);
int8_t t52_c_c_I()	{ return t52_c++; }
int8_t t52_c_uc_I()	{ return t52_uc++; }
int16_t t52_s_s_I()	{ return t52_s++; }
int16_t t52_s_us_I()	{ return t52_us++; }
int32_t t52_i_i_I()	{ return t52_i++; }
int32_t t52_i_ui_I()	{ return t52_ui++; }
int64_t t52_l_l_I()	{ return t52_l++; }
int64_t t52_l_ul_I()	{ return t52_ul++; }
float32_t t52_f_f_I()	{ return t52_f++; }
float64_t t52_d_d_I()	{ return t52_d++; }
auto t52_v_v_I()	{ return t52_v++; }
int8_t t52_c_c_D()	{ return t52_c--; }
int8_t t52_c_uc_D()	{ return t52_uc--; }
int16_t t52_s_s_D()	{ return t52_s--; }
int16_t t52_s_us_D()	{ return t52_us--; }
int32_t t52_i_i_D()	{ return t52_i--; }
int32_t t52_i_ui_D()	{ return t52_ui--; }
int64_t t52_l_l_D()	{ return t52_l--; }
int64_t t52_l_ul_D()	{ return t52_ul--; }
float32_t t52_f_f_D()	{ return t52_f--; }
float64_t t52_d_d_D()	{ return t52_d--; }
auto t52_v_v_D()	{ return t52_v--; }
int8_t t52_c_I_c()	{ return ++t52_c; }
int8_t t52_c_I_uc()	{ return ++t52_uc; }
int16_t t52_s_I_s()	{ return ++t52_s; }
int16_t t52_s_I_us()	{ return ++t52_us; }
int32_t t52_i_I_i()	{ return ++t52_i; }
int32_t t52_i_I_ui()	{ return ++t52_ui; }
int64_t t52_l_I_l()	{ return ++t52_l; }
int64_t t52_l_I_ul()	{ return ++t52_ul; }
float32_t t52_f_I_f()	{ return ++t52_f; }
float64_t t52_d_I_d()	{ return ++t52_d; }
auto t52_v_I_v()	{ return ++t52_v; }
int8_t t52_c_D_c()	{ return --t52_c; }
int8_t t52_c_D_uc()	{ return --t52_uc; }
int16_t t52_s_D_s()	{ return --t52_s; }
int16_t t52_s_D_us()	{ return --t52_us; }
int32_t t52_i_D_i()	{ return --t52_i; }
int32_t t52_i_D_ui()	{ return --t52_ui; }
int64_t t52_l_D_l()	{ return --t52_l; }
int64_t t52_l_D_ul()	{ return --t52_ul; }
float32_t t52_f_D_f()	{ return --t52_f; }
float64_t t52_d_D_d()	{ return --t52_d; }
auto t52_v_D_v()	{ return --t52_v; }
void t52_c_A_c(int8_t a)	{ t52_c += a; }
void t52_c_A_uc(uint8_t a)	{ t52_c += a; }
void t52_c_A_s(int16_t a)	{ t52_c += a; }
void t52_c_A_us(uint16_t a)	{ t52_c += a; }
void t52_c_A_i(int32_t a)	{ t52_c += a; }
void t52_c_A_ui(uint32_t a)	{ t52_c += a; }
void t52_c_A_l(int64_t a)	{ t52_c += a; }
void t52_c_A_ul(uint64_t a)	{ t52_c += a; }
void t52_c_A_f(float32_t a)	{ t52_c += a; }
void t52_c_A_d(float64_t a)	{ t52_c += a; }
void t52_c_A_v(a)		{ t52_c += a; }
void t52_uc_A_c(int8_t a)	{ t52_uc += a; }
void t52_uc_A_uc(uint8_t a)	{ t52_uc += a; }
void t52_uc_A_s(int16_t a)	{ t52_uc += a; }
void t52_uc_A_us(uint16_t a)	{ t52_uc += a; }
void t52_uc_A_i(int32_t a)	{ t52_uc += a; }
void t52_uc_A_ui(uint32_t a)	{ t52_uc += a; }
void t52_uc_A_l(int64_t a)	{ t52_uc += a; }
void t52_uc_A_ul(uint64_t a)	{ t52_uc += a; }
void t52_uc_A_f(float32_t a)	{ t52_uc += a; }
void t52_uc_A_d(float64_t a)	{ t52_uc += a; }
void t52_uc_A_v(a)		{ t52_uc += a; }
void t52_s_A_c(int8_t a)	{ t52_s += a; }
void t52_s_A_uc(uint8_t a)	{ t52_s += a; }
void t52_s_A_s(int16_t a)	{ t52_s += a; }
void t52_s_A_us(uint16_t a)	{ t52_s += a; }
void t52_s_A_i(int32_t a)	{ t52_s += a; }
void t52_s_A_ui(uint32_t a)	{ t52_s += a; }
void t52_s_A_l(int64_t a)	{ t52_s += a; }
void t52_s_A_ul(uint64_t a)	{ t52_s += a; }
void t52_s_A_f(float32_t a)	{ t52_s += a; }
void t52_s_A_d(float64_t a)	{ t52_s += a; }
void t52_s_A_v(a)		{ t52_s += a; }
void t52_us_A_c(int8_t a)	{ t52_us += a; }
void t52_us_A_uc(uint8_t a)	{ t52_us += a; }
void t52_us_A_s(int16_t a)	{ t52_us += a; }
void t52_us_A_us(uint16_t a)	{ t52_us += a; }
void t52_us_A_i(int32_t a)	{ t52_us += a; }
void t52_us_A_ui(uint32_t a)	{ t52_us += a; }
void t52_us_A_l(int64_t a)	{ t52_us += a; }
void t52_us_A_ul(uint64_t a)	{ t52_us += a; }
void t52_us_A_f(float32_t a)	{ t52_us += a; }
void t52_us_A_d(float64_t a)	{ t52_us += a; }
void t52_us_A_v(a)		{ t52_us += a; }
void t52_i_A_c(int8_t a)	{ t52_i += a; }
void t52_i_A_uc(uint8_t a)	{ t52_i += a; }
void t52_i_A_s(int16_t a)	{ t52_i += a; }
void t52_i_A_us(uint16_t a)	{ t52_i += a; }
void t52_i_A_i(int32_t a)	{ t52_i += a; }
void t52_i_A_ui(uint32_t a)	{ t52_i += a; }
void t52_i_A_l(int64_t a)	{ t52_i += a; }
void t52_i_A_ul(uint64_t a)	{ t52_i += a; }
void t52_i_A_f(float32_t a)	{ t52_i += a; }
void t52_i_A_d(float64_t a)	{ t52_i += a; }
void t52_i_A_v(a)		{ t52_i += a; }
void t52_ui_A_c(int8_t a)	{ t52_ui += a; }
void t52_ui_A_uc(uint8_t a)	{ t52_ui += a; }
void t52_ui_A_s(int16_t a)	{ t52_ui += a; }
void t52_ui_A_us(uint16_t a)	{ t52_ui += a; }
void t52_ui_A_i(int32_t a)	{ t52_ui += a; }
void t52_ui_A_ui(uint32_t a)	{ t52_ui += a; }
void t52_ui_A_l(int64_t a)	{ t52_ui += a; }
void t52_ui_A_ul(uint64_t a)	{ t52_ui += a; }
void t52_ui_A_f(float32_t a)	{ t52_ui += a; }
void t52_ui_A_d(float64_t a)	{ t52_ui += a; }
void t52_ui_A_v(a)		{ t52_ui += a; }
void t52_l_S_c(int8_t a)	{ t52_l -= a; }
void t52_l_S_uc(uint8_t a)	{ t52_l -= a; }
void t52_l_S_s(int16_t a)	{ t52_l -= a; }
void t52_l_S_us(uint16_t a)	{ t52_l -= a; }
void t52_l_S_i(int32_t a)	{ t52_l -= a; }
void t52_l_S_ui(uint32_t a)	{ t52_l -= a; }
void t52_l_S_l(int64_t a)	{ t52_l -= a; }
void t52_l_S_ul(uint64_t a)	{ t52_l -= a; }
void t52_l_S_f(float32_t a)	{ t52_l -= a; }
void t52_l_S_d(float64_t a)	{ t52_l -= a; }
void t52_l_S_v(a)		{ t52_l -= a; }
void t52_ul_S_c(int8_t a)	{ t52_ul -= a; }
void t52_ul_S_uc(uint8_t a)	{ t52_ul -= a; }
void t52_ul_S_s(int16_t a)	{ t52_ul -= a; }
void t52_ul_S_us(uint16_t a)	{ t52_ul -= a; }
void t52_ul_S_i(int32_t a)	{ t52_ul -= a; }
void t52_ul_S_ui(uint32_t a)	{ t52_ul -= a; }
void t52_ul_S_l(int64_t a)	{ t52_ul -= a; }
void t52_ul_S_ul(uint64_t a)	{ t52_ul -= a; }
void t52_ul_S_f(float32_t a)	{ t52_ul -= a; }
void t52_ul_S_d(float64_t a)	{ t52_ul -= a; }
void t52_ul_S_v(a)		{ t52_ul -= a; }
void t52_f_S_c(int8_t a)	{ t52_f -= a; }
void t52_f_S_uc(uint8_t a)	{ t52_f -= a; }
void t52_f_S_s(int16_t a)	{ t52_f -= a; }
void t52_f_S_us(uint16_t a)	{ t52_f -= a; }
void t52_f_S_i(int32_t a)	{ t52_f -= a; }
void t52_f_S_ui(uint32_t a)	{ t52_f -= a; }
void t52_f_S_l(int64_t a)	{ t52_f -= a; }
void t52_f_S_ul(uint64_t a)	{ t52_f -= a; }
void t52_f_S_f(float32_t a)	{ t52_f -= a; }
void t52_f_S_d(float64_t a)	{ t52_f -= a; }
void t52_f_S_v(a)		{ t52_f -= a; }
void t52_d_S_c(int8_t a)	{ t52_d -= a; }
void t52_d_S_uc(uint8_t a)	{ t52_d -= a; }
void t52_d_S_s(int16_t a)	{ t52_d -= a; }
void t52_d_S_us(uint16_t a)	{ t52_d -= a; }
void t52_d_S_i(int32_t a)	{ t52_d -= a; }
void t52_d_S_ui(uint32_t a)	{ t52_d -= a; }
void t52_d_S_l(int64_t a)	{ t52_d -= a; }
void t52_d_S_ul(uint64_t a)	{ t52_d -= a; }
void t52_d_S_f(float32_t a)	{ t52_d -= a; }
void t52_d_S_d(float64_t a)	{ t52_d -= a; }
void t52_d_S_v(a)		{ t52_d -= a; }
void t52_v_S_c(int8_t a)	{ t52_v -= a; }
void t52_v_S_uc(uint8_t a)	{ t52_v -= a; }
void t52_v_S_s(int16_t a)	{ t52_v -= a; }
void t52_v_S_us(uint16_t a)	{ t52_v -= a; }
void t52_v_S_i(int32_t a)	{ t52_v -= a; }
void t52_v_S_ui(uint32_t a)	{ t52_v -= a; }
void t52_v_S_l(int64_t a)	{ t52_v -= a; }
void t52_v_S_ul(uint64_t a)	{ t52_v -= a; }
void t52_v_S_f(float32_t a)	{ t52_v -= a; }
void t52_v_S_d(float64_t a)	{ t52_v -= a; }
void t52_v_S_v(a)		{ t52_v -= a; }
void t52_reset() {
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0;
}
t52_ul = 0;
void t52_t0() {
    /* assuming first call (basically to have v as null) */
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
    if (t52_c_c_I() != 0.0 || t52_c_uc_I() != 0 ||
	t52_s_s_I() != 0 || t52_s_us_I() != 0.0 ||
	t52_i_i_I() != 0.0 || t52_i_ui_I() != 0 ||
	t52_l_l_I() != 0 || t52_l_ul_I() != 0.0 ||
	t52_f_f_I() != 0.0 || t52_d_d_I() != 0 ||
	t52_v_v_I() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != 1 || t52_uc != 1.0 ||
	t52_s != 1.0 || t52_us != 1 ||
	t52_i != 1 || t52_ui != 1.0 ||
	t52_l != 1.0 || t52_ul != 1 ||
	t52_f != 1 || t52_d != 1.0 ||
	t52_v != 1.0)
	print("error %d\n", __LINE__);
    if (t52_c_D_c() != 0 || t52_c_D_uc() != 0.0 ||
	t52_s_D_s() != 0.0 || t52_s_D_us() != 0 ||
	t52_i_D_i() != 0 || t52_i_D_ui() != 0.0 ||
	t52_l_D_l() != 0.0 || t52_l_D_ul() != 0 ||
	t52_f_D_f() != 0 || t52_d_D_d() != 0.0 ||
	t52_v_D_v() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
}
void t52_t1() {
    t52_reset();
    if (t52_c_c_I() != 0.0 || t52_c_uc_I() != 0 ||
	t52_s_s_I() != 0 || t52_s_us_I() != 0.0 ||
	t52_i_i_I() != 0.0 || t52_i_ui_I() != 0 ||
	t52_l_l_I() != 0 || t52_l_ul_I() != 0.0 ||
	t52_f_f_I() != 0.0 || t52_d_d_I() != 0 ||
	t52_v_v_I() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != 1 || t52_uc != 1.0 ||
	t52_s != 1.0 || t52_us != 1 ||
	t52_i != 1 || t52_ui != 1.0 ||
	t52_l != 1.0 || t52_ul != 1 ||
	t52_f != 1 || t52_d != 1.0 ||
	t52_v != 1.0)
	print("error %d\n", __LINE__);
    if (t52_c_D_c() != 0 || t52_c_D_uc() != 0.0 ||
	t52_s_D_s() != 0.0 || t52_s_D_us() != 0 ||
	t52_i_D_i() != 0 || t52_i_D_ui() != 0.0 ||
	t52_l_D_l() != 0.0 || t52_l_D_ul() != 0 ||
	t52_f_D_f() != 0 || t52_d_D_d() != 0.0 ||
	t52_v_D_v() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
}
void t52_t2() {
    t52_reset();
    t52_ul = 0x7fffffffffffffff;
    if (t52_l_ul_I() != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
    if (t52_l_ul_I() != -0x8000000000000000)	print("error %d\n", __LINE__);
    if (t52_l_ul_I() != -0x7fffffffffffffff)	print("error %d\n", __LINE__);
    if (t52_l_D_ul() != -0x7fffffffffffffff)	print("error %d\n", __LINE__);
    if (t52_l_D_ul() != -0x8000000000000000)	print("error %d\n", __LINE__);
    if (t52_ul != 0x8000000000000000)		print("error %d\n", __LINE__);
}
void t52_t3() {
    t52_reset();
    if (t52_c_c_D() != 0.0 || t52_c_uc_D() != 0 ||
	t52_s_s_D() != 0 || t52_s_us_D() != 0.0 ||
	t52_i_i_D() != 0.0 || t52_i_ui_D() != 0 ||
	t52_l_l_D() != 0 || t52_l_ul_D() != 0.0 ||
	t52_f_f_D() != 0.0 || t52_d_d_D() != 0 ||
	t52_v_v_D() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != -1 || t52_uc != 0xff.0 ||
	t52_s != -1.0 || t52_us != 0xffff ||
	t52_i != -1 || t52_ui != 0xffffffff.0 ||
	t52_l != -1.0 || t52_ul != 0xffffffffffffffff ||
	t52_f != -1 || t52_d != -1.0 ||
	t52_v != -1.0)
	print("error %d\n", __LINE__);
    if (t52_c_I_c() != 0 || t52_c_I_uc() != 0.0 ||
	t52_s_I_s() != 0.0 || t52_s_I_us() != 0 ||
	t52_i_I_i() != 0 || t52_i_I_ui() != 0.0 ||
	t52_l_I_l() != 0.0 || t52_l_I_ul() != 0 ||
	t52_f_I_f() != 0 || t52_d_I_d() != 0.0 ||
	t52_v_I_v() != 0)
	print("error %d\n", __LINE__);
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
}
void t52_t4() {
    int8_t		xc;	uint8_t		xuc;
    int16_t		xs;	uint16_t	xus;
    int32_t		xi;	uint32_t	xui;
    int64_t		xl;	uint64_t	xul;
    float32_t		xf;	float64_t	xd;
    auto		xv;
    t52_reset();
    xc = t52_c++;	xuc = t52_uc++;	xs = t52_s++;	xus = t52_us++;
    xi = t52_i++;	xui = t52_ui++;	xl = t52_l++;	xul = t52_ul++;
    xf = t52_f++;	xd = t52_d++;	xv = t52_v++;
    if (xc != 0 || xuc != 0.0 ||
	xs != 0.0 || xus != 0 ||
	xi != 0 || xui != 0.0 ||
	xl != 0.0 || xul != 0 ||
	xf != 0 || xd != 0.0 ||
	xv != 0.0)
	print("error %d\n", __LINE__);
    if (t52_c != 1 || t52_uc != 1.0 ||
	t52_s != 1.0 || t52_us != 1 ||
	t52_i != 1 || t52_ui != 1.0 ||
	t52_l != 1.0 || t52_ul != 1 ||
	t52_f != 1 || t52_d != 1.0 ||
	t52_v != 1.0)
	print("error %d\n", __LINE__);
    xc = t52_c--;	xuc = t52_uc--;	xs = t52_s--;	xus = t52_us--;
    xi = t52_i--;	xui = t52_ui--;	xl = t52_l--;	xul = t52_ul--;
    xf = t52_f--;	xd = t52_d--;	xv = t52_v--;
    if (xc != 1.0 || xuc != 1 ||
	xs != 1 || xus != 1.0 ||
	xi != 1.0 || xui != 1 ||
	xl != 1 || xul != 1.0 ||
	xf != 1.0 || xd != 1 ||
	xv != 1)
	print("error %d\n", __LINE__);
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
    xc = ++t52_c;	xuc = ++t52_uc;	xs = ++t52_s;	xus = ++t52_us;
    xi = ++t52_i;	xui = ++t52_ui;	xl = ++t52_l;	xul = ++t52_ul;
    xf = ++t52_f;	xd = ++t52_d;	xv = ++t52_v;
    if (xc != t52_c || xuc != t52_uc ||
	xs != t52_s || xus != t52_us ||
	xi != t52_i || xui != t52_ui ||
	xl != t52_l || xul != t52_ul ||
	xf != t52_f || xd != t52_d ||
	xv != t52_v)
	print("error %d\n", __LINE__);
    t52_c = --xv;	t52_uc = --xd;	t52_s = --xf;	t52_us = --xul;
    t52_i = --xl;	t52_ui = --xui;	t52_l = --xi;	t52_ul = --xus;
    t52_f = --xs;	t52_d = --xuc;	t52_v = --xc;
    if (t52_c != 0.0 || t52_uc != 0 ||
	t52_s != 0 || t52_us != 0.0 ||
	t52_i != 0.0 || t52_ui != 0 ||
	t52_l != 0 || t52_ul != 0.0 ||
	t52_f != 0.0 || t52_d != 0 ||
	t52_v != 0)
	print("error %d\n", __LINE__);
}
/* float comparisons may vary due to conversion... */
void t52_t5() {
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x7f;
    t52_c_A_c(t52_c);
    if (t52_c != -0x02)			print("error %d\n", __LINE__);
    t52_c_A_uc(t52_uc);
    if (t52_c !=  0x7d)			print("error %d\n", __LINE__);
    t52_c_A_s(t52_s);
    if (t52_c != -0x04)			print("error %d\n", __LINE__);
    t52_c_A_us(t52_us);
    if (t52_c !=  0x7b)			print("error %d\n", __LINE__);
    t52_c_A_i(t52_i);
    if (t52_c != -0x06)			print("error %d\n", __LINE__);
    t52_c_A_ui(t52_ui);
    if (t52_c !=  0x79)			print("error %d\n", __LINE__);
    t52_c_A_l(t52_l);
    if (t52_c != -0x08)			print("error %d\n", __LINE__);
    t52_c_A_ul(t52_ul);
    if (t52_c !=  0x77)			print("error %d\n", __LINE__);
    t52_c_A_f(t52_f);
    if (t52_c != -0x0a)			print("error %d\n", __LINE__);
    t52_c_A_d(t52_d);
    if (t52_c !=  0x75)			print("error %d\n", __LINE__);
    t52_c_A_v(t52_v);
    if (t52_c != -0x0c)			print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x81;
    t52_uc_A_c(t52_c);
    if (t52_uc != 0x02)			print("error %d\n", __LINE__);
    t52_uc_A_uc(t52_uc);
    if (t52_uc != 0x04)			print("error %d\n", __LINE__);
    t52_uc_A_s(t52_s);
    if (t52_uc != 0x85)			print("error %d\n", __LINE__);
    t52_uc_A_us(t52_us);
    if (t52_uc != 0x06)			print("error %d\n", __LINE__);
    t52_uc_A_i(t52_i);
    if (t52_uc != 0x87)			print("error %d\n", __LINE__);
    t52_uc_A_ui(t52_ui);
    if (t52_uc != 0x08)			print("error %d\n", __LINE__);
    t52_uc_A_l(t52_l);
    if (t52_uc != 0x89)			print("error %d\n", __LINE__);
    t52_uc_A_ul(t52_ul);
    if (t52_uc != 0x0a)			print("error %d\n", __LINE__);
    t52_uc_A_f(t52_f);
    if (t52_uc != 0x8b)			print("error %d\n", __LINE__);
    t52_uc_A_d(t52_d);
    if (t52_uc != 0x0c)			print("error %d\n", __LINE__);
    t52_uc_A_v(t52_v);
    if (t52_uc != 0x8d)			print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x8001;
    t52_s_A_c(t52_c);
    if (t52_s != -0x7ffe)		print("error %d\n", __LINE__);
    t52_s_A_uc(t52_uc);
    if (t52_s != -0x7ffd)		print("error %d\n", __LINE__);
    t52_s_A_s(t52_s);
    if (t52_s !=  0x0006)		print("error %d\n", __LINE__);
    t52_s_A_us(t52_us);
    if (t52_s != -0x7ff9)		print("error %d\n", __LINE__);
    t52_s_A_i(t52_i);
    if (t52_s !=  0x0008)		print("error %d\n", __LINE__);
    t52_s_A_ui(t52_ui);
    if (t52_s != -0x7ff7)		print("error %d\n", __LINE__);
    t52_s_A_l(t52_l);
    if (t52_s !=  0x000a)		print("error %d\n", __LINE__);
    t52_s_A_ul(t52_ul);
    if (t52_s != -0x7ff5)		print("error %d\n", __LINE__);
    t52_s_A_f(t52_f);
    if (t52_s !=  0x000c)		print("error %d\n", __LINE__);
    t52_s_A_d(t52_d);
    if (t52_s != -0x7ff3)		print("error %d\n", __LINE__);
    t52_s_A_v(t52_v);
    if (t52_s !=  0x000e)		print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x7fff;
    t52_us_A_c(t52_c);
    if (t52_us != 0x7ffe)		print("error %d\n", __LINE__);
    t52_us_A_uc(t52_uc);
    if (t52_us != 0x80fd)		print("error %d\n", __LINE__);
    t52_us_A_s(t52_s);
    if (t52_us != 0x00fc)		print("error %d\n", __LINE__);
    t52_us_A_us(t52_us);
    if (t52_us != 0x01f8)		print("error %d\n", __LINE__);
    t52_us_A_i(t52_i);
    if (t52_us != 0x81f7)		print("error %d\n", __LINE__);
    t52_us_A_ui(t52_ui);
    if (t52_us != 0x01f6)		print("error %d\n", __LINE__);
    t52_us_A_l(t52_l);
    if (t52_us != 0x81f5)		print("error %d\n", __LINE__);
    t52_us_A_ul(t52_ul);
    if (t52_us != 0x01f4)		print("error %d\n", __LINE__);
    t52_us_A_f(t52_f);
    if (t52_us != 0x81f3)		print("error %d\n", __LINE__);
    t52_us_A_d(t52_d);
    if (t52_us != 0x01f2)		print("error %d\n", __LINE__);
    t52_us_A_v(t52_v);
    if (t52_us != 0x81f1)		print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0xa5a5a5a5;
    t52_i_A_c(t52_c);
    if (t52_i != -0x5a5a5ab6)		print("error %d\n", __LINE__);
    t52_i_A_uc(t52_uc);
    if (t52_i != -0x5a5a5a11)		print("error %d\n", __LINE__);
    t52_i_A_s(t52_s);
    if (t52_i != -0x5a5ab46c)		print("error %d\n", __LINE__);
    t52_i_A_us(t52_us);
    if (t52_i != -0x5a5a0ec7)		print("error %d\n", __LINE__);
    t52_i_A_i(t52_i);
    if (t52_i !=  0x4b4be272)		print("error %d\n", __LINE__);
    t52_i_A_ui(t52_ui);
    if (t52_i != -0x0f0e77e9)		print("error %d\n", __LINE__);
    t52_i_A_l(t52_l);
    if (t52_i != -0x6968d244)		print("error %d\n", __LINE__);
    t52_i_A_ul(t52_ul);
    if (t52_i !=  0x3c3cd361)		print("error %d\n", __LINE__);
    /* truncate overflow */
    if (t52_i_A_f(t52_f), t52_i == -0x80000000) {
	t52_i_A_d(t52_d);
	if (t52_i !=  0x25a5a5a5)	print("error %d\n", __LINE__);
	t52_i_A_v(t52_v);
	if (t52_i != -0x34b4b4b6)	print("error %d\n", __LINE__);
    }
    else {
	if (t52_i != 0x7fffffff)	print("error %d\n", __LINE__);
	t52_i_A_d(t52_d);
	if (t52_i !=  0x7fffffff)	print("error %d\n", __LINE__);
	t52_i_A_v(t52_v);
	if (t52_i !=  0x25a5a5a4)	print("error %d\n", __LINE__);
    }
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x80007ffe;
    t52_ui_A_c(t52_c);
    if (t52_ui != 0x80007ffc)		print("error %d\n", __LINE__);
    t52_ui_A_uc(t52_uc);
    if (t52_ui != 0x800080fa)		print("error %d\n", __LINE__);
    t52_ui_A_s(t52_s);
    if (t52_ui != 0x800100f8)		print("error %d\n", __LINE__);
    t52_ui_A_us(t52_us);
    if (t52_ui != 0x800180f6)		print("error %d\n", __LINE__);
    t52_ui_A_i(t52_i);
    if (t52_ui != 0x000200f4)		print("error %d\n", __LINE__);
    t52_ui_A_ui(t52_ui);
    if (t52_ui != 0x000401e8)		print("error %d\n", __LINE__);
    t52_ui_A_l(t52_l);
    if (t52_ui != 0x800481e6)		print("error %d\n", __LINE__);
    t52_ui_A_ul(t52_ul);
    if (t52_ui != 0x000501e4)		print("error %d\n", __LINE__);
    /* truncate overflow */
    if (t52_ui_A_f(t52_f), t52_ui == 0x80000000) {
	t52_ui_A_d(t52_d);
	if (t52_ui != 0x80000000)	print("error %d\n", __LINE__);
	t52_ui_A_v(t52_v);
	if (t52_ui != 0x00007ffe)	print("error %d\n", __LINE__);
    }
    else {
	if (t52_ui != 0x7fffffff)	print("error %d\n", __LINE__);
	t52_ui_A_d(t52_d);
	if (t52_ui != 0x7fffffff)	print("error %d\n", __LINE__);
	t52_ui_A_v(t52_v);
	if (t52_ui != 0x00007ffd)	print("error %d\n", __LINE__);
    }
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0xfffffffffffffffe;
    t52_l_S_c(t52_c);
    if (t52_l !=  0x0000000000000000)	print("error %d\n", __LINE__);
    t52_l_S_uc(t52_uc);
    if (t52_l != -0x00000000000000fe)	print("error %d\n", __LINE__);
    t52_l_S_s(t52_s);
    if (t52_l != -0x00000000000000fc)	print("error %d\n", __LINE__);
    t52_l_S_us(t52_us);
    if (t52_l != -0x00000000000100fa)	print("error %d\n", __LINE__);
    t52_l_S_i(t52_i);
    if (t52_l != -0x00000000000100f8)	print("error %d\n", __LINE__);
    t52_l_S_ui(t52_ui);
    if (t52_l != -0x00000001000100f6)	print("error %d\n", __LINE__);
    t52_l_S_l(t52_l);
    if (t52_l !=  0x0000000000000000)	print("error %d\n", __LINE__);
    t52_l_S_ul(t52_ul);
    if (t52_l !=  0x0000000000000002)	print("error %d\n", __LINE__);
    if (t52_l_S_f(t52_f), t52_l == -0x8000000000000000) {
	t52_l_S_d(t52_d);
	if (t52_l != -0x8000000000000000)print("error %d\n", __LINE__);
	t52_l_S_v(t52_v);
	if (t52_l != -0x7ffffffffffffffe)print("error %d\n", __LINE__);
    }
    else {
	if (t52_l != 0x0000000000000001)print("error %d\n", __LINE__);
	t52_l_S_d(t52_d);
	if (t52_l != 0x0000000000000800)print("error %d\n", __LINE__);
	t52_l_S_v(t52_v);
	if (t52_l != 0x0000000000000802)print("error %d\n", __LINE__);
    }
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x8000000000000001;
    t52_ul_S_c(t52_c);
    if (t52_ul != 0x8000000000000000)	print("error %d\n", __LINE__);
    t52_ul_S_uc(t52_uc);
    if (t52_ul != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
    t52_ul_S_s(t52_s);
    if (t52_ul != 0x7ffffffffffffffe)	print("error %d\n", __LINE__);
    t52_ul_S_us(t52_us);
    if (t52_ul != 0x7ffffffffffffffd)	print("error %d\n", __LINE__);
    t52_ul_S_i(t52_i);
    if (t52_ul != 0x7ffffffffffffffc)	print("error %d\n", __LINE__);
    t52_ul_S_ui(t52_ui);
    if (t52_ul != 0x7ffffffffffffffb)	print("error %d\n", __LINE__);
    t52_ul_S_l(t52_l);
    if (t52_ul != 0xfffffffffffffffa)	print("error %d\n", __LINE__);
    t52_ul_S_ul(t52_ul);
    if (t52_ul != 0x0000000000000000)	print("error %d\n", __LINE__);
    t52_ul_S_f(t52_f);
    if (t52_ul != 0x8000000000000000)	print("error %d\n", __LINE__);
    t52_ul_S_d(t52_d);
    if (t52_ul != 0x0000000000000000)	print("error %d\n", __LINE__);
    t52_ul_S_v(t52_v);
    if (t52_ul != 0x7fffffffffffffff)	print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x800000.0;
    t52_f_S_c(t52_c);
    if (t52_f !=  0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_uc(t52_uc);
    if (t52_f !=  0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_s(t52_s);
    if (t52_f !=  0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_us(t52_us);
    if (t52_f !=  0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_i(t52_i);
    if (t52_f != -0x0000000.0)		print("error %d\n", __LINE__);
    t52_f_S_ui(t52_ui);
    if (t52_f != -0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_l(t52_l);
    if (t52_f != -0x1000000.0)		print("error %d\n", __LINE__);
    t52_f_S_ul(t52_ul);
    if (t52_f != -0x1800000.0)		print("error %d\n", __LINE__);
    t52_f_S_f(t52_f);
    if (t52_f !=  0x0000000.0)		print("error %d\n", __LINE__);
    t52_f_S_d(t52_d);
    if (t52_f != -0x0800000.0)		print("error %d\n", __LINE__);
    t52_f_S_v(t52_v);
    if (t52_f != -0x1000000.0)		print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0xffff.0;
    t52_d_S_c(t52_c);
    if (t52_d !=  0x10000.0)		print("error %d\n", __LINE__);
    t52_d_S_uc(t52_uc);
    if (t52_d !=  0x0ff01.0)		print("error %d\n", __LINE__);
    t52_d_S_s(t52_s);
    if (t52_d !=  0x0ff02.0)		print("error %d\n", __LINE__);
    t52_d_S_us(t52_us);
    if (t52_d != -0x000fd.0)		print("error %d\n", __LINE__);
    t52_d_S_i(t52_i);
    if (t52_d != -0x100fc.0)		print("error %d\n", __LINE__);
    t52_d_S_ui(t52_ui);
    if (t52_d != -0x200fb.0)		print("error %d\n", __LINE__);
    t52_d_S_l(t52_l);
    if (t52_d != -0x300fa.0)		print("error %d\n", __LINE__);
    t52_d_S_ul(t52_ul);
    if (t52_d != -0x400f9.0)		print("error %d\n", __LINE__);
    t52_d_S_f(t52_f);
    if (t52_d != -0x500f8.0)		print("error %d\n", __LINE__);
    t52_d_S_d(t52_d);
    if (t52_d !=  0x00000.0)		print("error %d\n", __LINE__);
    t52_d_S_v(t52_v);
    if (t52_d != -0x0ffff.0)		print("error %d\n", __LINE__);
    t52_c = t52_uc = t52_s = t52_us = t52_i = t52_ui =
	t52_l = t52_ul = t52_f = t52_d = t52_v = 0x7fffffffffffffff;
    t52_v_S_c(t52_c);
    if (t52_v !=  0x8000000000000000)	print("error %d\n", __LINE__);
    t52_v_S_uc(t52_uc);
    if (t52_v !=  0x7fffffffffffff01)	print("error %d\n", __LINE__);
    t52_v_S_s(t52_s);
    if (t52_v !=  0x7fffffffffffff02)	print("error %d\n", __LINE__);
    t52_v_S_us(t52_us);
    if (t52_v !=  0x7ffffffffffeff03)	print("error %d\n", __LINE__);
    t52_v_S_i(t52_i);
    if (t52_v !=  0x7ffffffffffeff04)	print("error %d\n", __LINE__);
    t52_v_S_ui(t52_ui);
    if (t52_v !=  0x7ffffffefffeff05)	print("error %d\n", __LINE__);
    t52_v_S_l(t52_l);
    if (t52_v != -0x00000001000100fa)	print("error %d\n", __LINE__);
    t52_v_S_ul(t52_ul);
    if (t52_v != -0x80000001000100f9)	print("error %d\n", __LINE__);
    t52_v_S_f(t52_f);
    if (t52_v != -0x10000000100010000.0 || typeof(t52_v) != typeof(0.0))
	print("error %d\n", __LINE__);
    t52_v_S_d(t52_d);
    if (t52_v != -0x18000000100010000.0)print("error %d\n", __LINE__);
    t52_v_S_v(t52_v);
    if (t52_v !=  0.0)			print("error %d\n", __LINE__);
}
t52_t0();
t52_t1();
t52_t2();
t52_t3();
t52_t4();
t52_t5();
class t52_c2_t {
    int32_t	i;	uint32_t	ui;
    int64_t	l;	uint64_t	ul;
    float32_t	f;	float64_t	d;
    auto	v;
    int32_t	ci;	uint32_t	cui;
    int64_t	cl;	uint64_t	cul;
    float32_t	cf;	float64_t	cd;
    auto	cv;
    void i_Ag_i()	{ i += t52_i; }
    void i_Ag_ui()	{ i += t52_ui; }
    void i_Ag_l()	{ i += t52_l; }
    void i_Ag_ul()	{ i += t52_ul; }
    void i_Ag_f()	{ i += t52_f; }
    void i_Ag_d()	{ i += t52_d; }
    void i_Ag_v()	{ i += t52_v; }
    void ui_Ag_i()	{ ui += t52_i; }
    void ui_Ag_ui()	{ ui += t52_ui; }
    void ui_Ag_l()	{ ui += t52_l; }
    void ui_Ag_ul()	{ ui += t52_ul; }
    void ui_Ag_f()	{ ui += t52_f; }
    void ui_Ag_d()	{ ui += t52_d; }
    void ui_Ag_v()	{ ui += t52_v; }
    void l_Ag_i()	{ l += t52_i; }
    void l_Ag_ui()	{ l += t52_ui; }
    void l_Ag_l()	{ l += t52_l; }
    void l_Ag_ul()	{ l += t52_ul; }
    void l_Ag_f()	{ l += t52_f; }
    void l_Ag_d()	{ l += t52_d; }
    void l_Ag_v()	{ l += t52_v; }
    void ul_Ag_i()	{ ul += t52_i; }
    void ul_Ag_ui()	{ ul += t52_ui; }
    void ul_Ag_l()	{ ul += t52_l; }
    void ul_Ag_ul()	{ ul += t52_ul; }
    void ul_Ag_f()	{ ul += t52_f; }
    void ul_Ag_d()	{ ul += t52_d; }
    void ul_Ag_v()	{ ul += t52_v; }
    void f_Ag_i()	{ f += t52_i; }
    void f_Ag_ui()	{ f += t52_ui; }
    void f_Ag_l()	{ f += t52_l; }
    void f_Ag_ul()	{ f += t52_ul; }
    void f_Ag_f()	{ f += t52_f; }
    void f_Ag_d()	{ f += t52_d; }
    void f_Ag_v()	{ f += t52_v; }
    void d_Ag_i()	{ d += t52_i; }
    void d_Ag_ui()	{ d += t52_ui; }
    void d_Ag_l()	{ d += t52_l; }
    void d_Ag_ul()	{ d += t52_ul; }
    void d_Ag_f()	{ d += t52_f; }
    void d_Ag_d()	{ d += t52_d; }
    void d_Ag_v()	{ d += t52_v; }
    void v_Ag_i()	{ v += t52_i; }
    void v_Ag_ui()	{ v += t52_ui; }
    void v_Ag_l()	{ v += t52_l; }
    void v_Ag_ul()	{ v += t52_ul; }
    void v_Ag_f()	{ v += t52_f; }
    void v_Ag_d()	{ v += t52_d; }
    void v_Ag_v()	{ v += t52_v; }
    void i_gA_i()	{ t52_i += i; }
    void i_gA_ui()	{ t52_i += ui; }
    void i_gA_l()	{ t52_i += l; }
    void i_gA_ul()	{ t52_i += ul; }
    void i_gA_f()	{ t52_i += f; }
    void i_gA_d()	{ t52_i += d; }
    void i_gA_v()	{ t52_i += v; }
    void ui_gA_i()	{ t52_ui += i; }
    void ui_gA_ui()	{ t52_ui += ui; }
    void ui_gA_l()	{ t52_ui += l; }
    void ui_gA_ul()	{ t52_ui += ul; }
    void ui_gA_f()	{ t52_ui += f; }
    void ui_gA_d()	{ t52_ui += d; }
    void ui_gA_v()	{ t52_ui += v; }
    void l_gA_i()	{ t52_l += i; }
    void l_gA_ui()	{ t52_l += ui; }
    void l_gA_l()	{ t52_l += l; }
    void l_gA_ul()	{ t52_l += ul; }
    void l_gA_f()	{ t52_l += f; }
    void l_gA_d()	{ t52_l += d; }
    void l_gA_v()	{ t52_l += v; }
    void ul_gA_i()	{ t52_ul += i; }
    void ul_gA_ui()	{ t52_ul += ui; }
    void ul_gA_l()	{ t52_ul += l; }
    void ul_gA_ul()	{ t52_ul += ul; }
    void ul_gA_f()	{ t52_ul += f; }
    void ul_gA_d()	{ t52_ul += d; }
    void ul_gA_v()	{ t52_ul += v; }
    void f_gA_i()	{ t52_f += i; }
    void f_gA_ui()	{ t52_f += ui; }
    void f_gA_l()	{ t52_f += l; }
    void f_gA_ul()	{ t52_f += ul; }
    void f_gA_f()	{ t52_f += f; }
    void f_gA_d()	{ t52_f += d; }
    void f_gA_v()	{ t52_f += v; }
    void d_gA_i()	{ t52_d += i; }
    void d_gA_ui()	{ t52_d += ui; }
    void d_gA_l()	{ t52_d += l; }
    void d_gA_ul()	{ t52_d += ul; }
    void d_gA_f()	{ t52_d += f; }
    void d_gA_d()	{ t52_d += d; }
    void d_gA_v()	{ t52_d += v; }
    void v_gA_i()	{ t52_v += i; }
    void v_gA_ui()	{ t52_v += ui; }
    void v_gA_l()	{ t52_v += l; }
    void v_gA_ul()	{ t52_v += ul; }
    void v_gA_f()	{ t52_v += f; }
    void v_gA_d()	{ t52_v += d; }
    void v_gA_v()	{ t52_v += v; }
    void i_I_i()	{ i = i + 1; }
    void i_I_ui()	{ i = ui + 1; }
    void i_I_l()	{ i = l + 1; }
    void i_I_ul()	{ i = ul + 1; }
    void i_I_f()	{ i = f + 1; }
    void i_I_d()	{ i = d + 1; }
    void i_I_v()	{ i = v + 1; }
    void ui_I_i()	{ ui = i + 1; }
    void ui_I_ui()	{ ui = ui + 1; }
    void ui_I_l()	{ ui = l + 1; }
    void ui_I_ul()	{ ui = ul + 1; }
    void ui_I_f()	{ ui = f + 1; }
    void ui_I_d()	{ ui = d + 1; }
    void ui_I_v()	{ ui = v + 1; }
    void l_I_i()	{ l = i + 1; }
    void l_I_ui()	{ l = ui + 1; }
    void l_I_l()	{ l = l + 1; }
    void l_I_ul()	{ l = ul + 1; }
    void l_I_f()	{ l = f + 1; }
    void l_I_d()	{ l = d + 1; }
    void l_I_v()	{ l = v + 1; }
    void ul_I_i()	{ ul = i + 1; }
    void ul_I_ui()	{ ul = ui + 1; }
    void ul_I_l()	{ ul = l + 1; }
    void ul_I_ul()	{ ul = ul + 1; }
    void ul_I_f()	{ ul = f + 1; }
    void ul_I_d()	{ ul = d + 1; }
    void ul_I_v()	{ ul = v + 1; }
    void f_I_i()	{ f = i + 1; }
    void f_I_ui()	{ f = ui + 1; }
    void f_I_l()	{ f = l + 1; }
    void f_I_ul()	{ f = ul + 1; }
    void f_I_f()	{ f = f + 1; }
    void f_I_d()	{ f = d + 1; }
    void f_I_v()	{ f = v + 1; }
    void d_I_i()	{ d = i + 1; }
    void d_I_ui()	{ d = ui + 1; }
    void d_I_l()	{ d = l + 1; }
    void d_I_ul()	{ d = ul + 1; }
    void d_I_f()	{ d = f + 1; }
    void d_I_d()	{ d = d + 1; }
    void d_I_v()	{ d = v + 1; }
    void v_I_i()	{ v = i + 1; }
    void v_I_ui()	{ v = ui + 1; }
    void v_I_l()	{ v = l + 1; }
    void v_I_ul()	{ v = ul + 1; }
    void v_I_f()	{ v = f + 1; }
    void v_I_d()	{ v = d + 1; }
    void v_I_v()	{ v = v + 1; }
    void i_Ig_i()	{ i = t52_i + 1; }
    void i_Ig_ui()	{ i = t52_ui + 1; }
    void i_Ig_l()	{ i = t52_l + 1; }
    void i_Ig_ul()	{ i = t52_ul + 1; }
    void i_Ig_f()	{ i = t52_f + 1; }
    void i_Ig_d()	{ i = t52_d + 1; }
    void i_Ig_v()	{ i = t52_v + 1; }
    void ui_Ig_i()	{ ui = t52_i + 1; }
    void ui_Ig_ui()	{ ui = t52_ui + 1; }
    void ui_Ig_l()	{ ui = t52_l + 1; }
    void ui_Ig_ul()	{ ui = t52_ul + 1; }
    void ui_Ig_f()	{ ui = t52_f + 1; }
    void ui_Ig_d()	{ ui = t52_d + 1; }
    void ui_Ig_v()	{ ui = t52_v + 1; }
    void l_Ig_i()	{ l = t52_i + 1; }
    void l_Ig_ui()	{ l = t52_ui + 1; }
    void l_Ig_l()	{ l = t52_l + 1; }
    void l_Ig_ul()	{ l = t52_ul + 1; }
    void l_Ig_f()	{ l = t52_f + 1; }
    void l_Ig_d()	{ l = t52_d + 1; }
    void l_Ig_v()	{ l = t52_v + 1; }
    void ul_Ig_i()	{ ul = t52_i + 1; }
    void ul_Ig_ui()	{ ul = t52_ui + 1; }
    void ul_Ig_l()	{ ul = t52_l + 1; }
    void ul_Ig_ul()	{ ul = t52_ul + 1; }
    void ul_Ig_f()	{ ul = t52_f + 1; }
    void ul_Ig_d()	{ ul = t52_d + 1; }
    void ul_Ig_v()	{ ul = t52_v + 1; }
    void f_Ig_i()	{ f = t52_i + 1; }
    void f_Ig_ui()	{ f = t52_ui + 1; }
    void f_Ig_l()	{ f = t52_l + 1; }
    void f_Ig_ul()	{ f = t52_ul + 1; }
    void f_Ig_f()	{ f = t52_f + 1; }
    void f_Ig_d()	{ f = t52_d + 1; }
    void f_Ig_v()	{ f = t52_v + 1; }
    void d_Ig_i()	{ d = t52_i + 1; }
    void d_Ig_ui()	{ d = t52_ui + 1; }
    void d_Ig_l()	{ d = t52_l + 1; }
    void d_Ig_ul()	{ d = t52_ul + 1; }
    void d_Ig_f()	{ d = t52_f + 1; }
    void d_Ig_d()	{ d = t52_d + 1; }
    void d_Ig_v()	{ d = t52_v + 1; }
    void v_Ig_i()	{ v = t52_i + 1; }
    void v_Ig_ui()	{ v = t52_ui + 1; }
    void v_Ig_l()	{ v = t52_l + 1; }
    void v_Ig_ul()	{ v = t52_ul + 1; }
    void v_Ig_f()	{ v = t52_f + 1; }
    void v_Ig_d()	{ v = t52_d + 1; }
    void v_Ig_v()	{ v = t52_v + 1; }
    void i_gI_i()	{ t52_i = i + 1; }
    void i_gI_ui()	{ t52_i = ui + 1; }
    void i_gI_l()	{ t52_i = l + 1; }
    void i_gI_ul()	{ t52_i = ul + 1; }
    void i_gI_f()	{ t52_i = f + 1; }
    void i_gI_d()	{ t52_i = d + 1; }
    void i_gI_v()	{ t52_i = v + 1; }
    void ui_gI_i()	{ t52_ui = i + 1; }
    void ui_gI_ui()	{ t52_ui = ui + 1; }
    void ui_gI_l()	{ t52_ui = l + 1; }
    void ui_gI_ul()	{ t52_ui = ul + 1; }
    void ui_gI_f()	{ t52_ui = f + 1; }
    void ui_gI_d()	{ t52_ui = d + 1; }
    void ui_gI_v()	{ t52_ui = v + 1; }
    void l_gI_i()	{ t52_l = i + 1; }
    void l_gI_ui()	{ t52_l = ui + 1; }
    void l_gI_l()	{ t52_l = l + 1; }
    void l_gI_ul()	{ t52_l = ul + 1; }
    void l_gI_f()	{ t52_l = f + 1; }
    void l_gI_d()	{ t52_l = d + 1; }
    void l_gI_v()	{ t52_l = v + 1; }
    void ul_gI_i()	{ t52_ul = i + 1; }
    void ul_gI_ui()	{ t52_ul = ui + 1; }
    void ul_gI_l()	{ t52_ul = l + 1; }
    void ul_gI_ul()	{ t52_ul = ul + 1; }
    void ul_gI_f()	{ t52_ul = f + 1; }
    void ul_gI_d()	{ t52_ul = d + 1; }
    void ul_gI_v()	{ t52_ul = v + 1; }
    void f_gI_i()	{ t52_f = i + 1; }
    void f_gI_ui()	{ t52_f = ui + 1; }
    void f_gI_l()	{ t52_f = l + 1; }
    void f_gI_ul()	{ t52_f = ul + 1; }
    void f_gI_f()	{ t52_f = f + 1; }
    void f_gI_d()	{ t52_f = d + 1; }
    void f_gI_v()	{ t52_f = v + 1; }
    void d_gI_i()	{ t52_d = i + 1; }
    void d_gI_ui()	{ t52_d = ui + 1; }
    void d_gI_l()	{ t52_d = l + 1; }
    void d_gI_ul()	{ t52_d = ul + 1; }
    void d_gI_f()	{ t52_d = f + 1; }
    void d_gI_d()	{ t52_d = d + 1; }
    void d_gI_v()	{ t52_d = v + 1; }
    void v_gI_i()	{ t52_v = i + 1; }
    void v_gI_ui()	{ t52_v = ui + 1; }
    void v_gI_l()	{ t52_v = l + 1; }
    void v_gI_ul()	{ t52_v = ul + 1; }
    void v_gI_f()	{ t52_v = f + 1; }
    void v_gI_d()	{ t52_v = d + 1; }
    void v_gI_v()	{ t52_v = v + 1; }
    void x7f()		{
	i = ui = t52_i = t52_ui = 0x7fffffff;
	l = ul = t52_l = t52_ul = 0x7fffffffffffffff;
	f = t52_f = 0x7f.0;
	d = t52_d = 0x7fff.0;
	v = t52_v = 0x7fffffffffffffffffffffff;
    }
    void c_x7f()	{
	i = ui = 0x7fffffff;
	l = ul = 0x7fffffffffffffff;
	f = 0x7f.0;
	d = 0x7fff.0;
	v = 0x7fffffffffffffffffffffff;
    }
    void g_x7f()	{
	t52_i = t52_ui = 0x7fffffff;
	t52_l = t52_ul = 0x7fffffffffffffff;
	t52_f = 0x7f.0;
	t52_d = 0x7fff.0;
	t52_v = 0x7fffffffffffffffffffffff;
    }
    void c_x80()	{
	i = ui = 0x80000000;
	l = ul = 0x8000000000000000;
	f = 0x80.0;
	d = 0x8000.0;
	v = 0x800000000000000000000000;
    }
    void g_x80()	{
	t52_i = t52_ui = 0x80000000;
	t52_l = t52_ul = 0x8000000000000000;
	t52_f = 0x80.0;
	t52_d = 0x8000.0;
	t52_v = 0x800000000000000000000000;
    }
    void c_x81()	{
	i = ui = 0x80000001;
	l = ul = 0x8000000000000001;
	f = 0x81.0;
	d = 0x8001.0;
	v = 0x800000000000000000000001;
    }
    void g_x81()	{
	t52_i = t52_ui = 0x80000001;
	t52_l = t52_ul = 0x8000000000000001;
	t52_f = 0x81.0;
	t52_d = 0x8001.0;
	t52_v = 0x800000000000000000000001;
    }
    void t0(int32_t xi, uint32_t xui, int64_t xl, uint64_t xul,
	    float32_t xf, float64_t xd, xv) {
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	i_Ag_i();
	if (i != -0x00000002)		print("error %d\n", __LINE__);
	i_Ag_ui();
	if (i !=  0x7fffffff)		print("error %d\n", __LINE__);
	i_Ag_l();
	if (i !=  0x7ffffffe)		print("error %d\n", __LINE__);
	i_Ag_ul();
	if (i !=  0x7fffffff)		print("error %d\n", __LINE__);
	i_Ag_f();
	if (i == -0x80000000) {
	    i_Ag_d();
	    if (i != -0x7f000000)	print("error %d\n", __LINE__);
	    i_Ag_v();
	    if (i != -0x7f000001)	print("error %d\n", __LINE__);
	}
	else if (i == 0x7fffffff) {
	    i_Ag_d();
	    if (i != 0x7fffffff)	print("error %d\n", __LINE__);
	    i_Ag_v();
	    if (i != 0x7ffffffe)	print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	ui_Ag_i();
	if (ui != 0x00000000)		print("error %d\n", __LINE__);
	ui_Ag_ui();
	if (ui != 0x80000001)		print("error %d\n", __LINE__);
	ui_Ag_l();
	if (ui != 0x80000000)		print("error %d\n", __LINE__);
	ui_Ag_ul();
	if (ui != 0x80000001)		print("error %d\n", __LINE__);
	ui_Ag_f();
	if (ui == 0x80000000) {
	    ui_Ag_d();
	    if (ui != 0x80000000)	print("error %d\n", __LINE__);
	    ui_Ag_v();
	    if (ui != 0x7fffffff)	print("error %d\n", __LINE__);
	}
	else if (ui == 0x7fffffff) {
	    ui_Ag_d();
	    if (ui != 0x7fffffff)	print("error %d\n", __LINE__);
	    ui_Ag_v();
	    if (ui != 0x7ffffffe)	print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	l_Ag_i();
	if (l != -0x7fffffff80000002)	print("error %d\n", __LINE__);
	l_Ag_ui();
	if (l != -0x7fffffff00000001)	print("error %d\n", __LINE__);
	l_Ag_l();
	if (l !=  0x00000000fffffffe)	print("error %d\n", __LINE__);
	l_Ag_ul();
	if (l != -0x7fffffff00000001)	print("error %d\n", __LINE__);
	l_Ag_f();
	if (l != -0x7fffffff00000000)	print("error %d\n", __LINE__);
	l_Ag_d();
	if (l != -0x7ffffffeff000000)	print("error %d\n", __LINE__);
	l_Ag_v();
	if (l !=  0x1000000100ffffff)	print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	ul_Ag_i();
	if (ul != 0x8000000080000000)	print("error %d\n", __LINE__);
	ul_Ag_ui();
	if (ul != 0x8000000100000001)	print("error %d\n", __LINE__);
	ul_Ag_l();
	if (ul != 0x0000000100000000)	print("error %d\n", __LINE__);
	ul_Ag_ul();
	if (ul != 0x8000000100000001)	print("error %d\n", __LINE__);
	ul_Ag_f();
	if (ul == 0x8000000000000000) {
	    ul_Ag_d();
	    if (ul != 0x8000000000000000)print("error %d\n", __LINE__);
	    ul_Ag_v();
	    if (ul != 0x0fffffffffffffff)print("error %d\n", __LINE__);
	}
	else if (ul == 0x8000000100000000) {
	    ul_Ag_d();
	    if (ul != 0x8000000101000000)print("error %d\n", __LINE__);
	    ul_Ag_v();
	    if (ul != 0x1000000100ffffff)print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	f_Ag_i();
	if (f != 0x00000000080000100.0)	print("error %d\n", __LINE__);
	f_Ag_ui();
	if (f != 0x00000000100000200.0)	print("error %d\n", __LINE__);
	f_Ag_l();
	if (f != 0x08000000000000000.0)	print("error %d\n", __LINE__);
	f_Ag_ul();
	if (f != 0x10000000000000000.0)	print("error %d\n", __LINE__);
	f_Ag_f();
	if (f != 0x10000000000000000.0)	print("error %d\n", __LINE__);
	f_Ag_d();
	if (f != 0x10000000000000000.0)	print("error %d\n", __LINE__);
	f_Ag_v();
	if (f != 0x19000000000000000.0)	print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	d_Ag_i();
	if (d != 0x00000000080ffffff.0)	print("error %d\n", __LINE__);
	d_Ag_ui();
	if (d != 0x00000000101000000.0)	print("error %d\n", __LINE__);
	d_Ag_l();
	if (d != 0x08000000101000000.0)	print("error %d\n", __LINE__);
	d_Ag_ul();
	if (d != 0x10000000101000000.0)	print("error %d\n", __LINE__);
	d_Ag_f();
	if (d != 0x10000000101000000.0)	print("error %d\n", __LINE__);
	d_Ag_d();
	if (d != 0x10000000102000000.0)	print("error %d\n", __LINE__);
	d_Ag_v();
	if (d != 0x19000000102000000.0)	print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	v_Ag_i();
	if (v != 0x0900000007ffffffe  )	print("error %d\n", __LINE__);
	v_Ag_ui();
	if (v != 0x090000000ffffffff  )	print("error %d\n", __LINE__);
	v_Ag_l();
	if (v != 0x110000000fffffffe  )	print("error %d\n", __LINE__);
	v_Ag_ul();
	if (v != 0x190000000ffffffff  )	print("error %d\n", __LINE__);
	v_Ag_f();
	if (v != 0x190000000fffff000.0)	print("error %d\n", __LINE__);
	v_Ag_d();
	if (v != 0x19000000100fff000.0)	print("error %d\n", __LINE__);
	v_Ag_v();
	if (v != 0x22000000100ffe000.0)	print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	i_gA_i();
	if (t52_i != -0x00000002)	print("error %d\n", __LINE__);
	i_gA_ui();
	if (t52_i !=  0x7fffffff)	print("error %d\n", __LINE__);
	i_gA_l();
	if (t52_i !=  0x7ffffffe)	print("error %d\n", __LINE__);
	i_gA_ul();
	if (t52_i !=  0x7fffffff)	print("error %d\n", __LINE__);
	i_gA_f();
	if (t52_i == -0x80000000) {
	    i_gA_d();
	    if (t52_i != -0x7f000000)	print("error %d\n", __LINE__);
	    i_gA_v();
	    if (t52_i != -0x7f000001)	print("error %d\n", __LINE__);
	}
	else if (t52_i == 0x7fffffff) {
	    i_gA_d();
	    if (t52_i != 0x7fffffff)	print("error %d\n", __LINE__);
	    i_gA_v();
	    if (t52_i != 0x7ffffffe)	print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	ui_gA_i();
	if (t52_ui != 0x00000000)	print("error %d\n", __LINE__);
	ui_gA_ui();
	if (t52_ui != 0x80000001)	print("error %d\n", __LINE__);
	ui_gA_l();
	if (t52_ui != 0x80000000)	print("error %d\n", __LINE__);
	ui_gA_ul();
	if (t52_ui != 0x80000001)	print("error %d\n", __LINE__);
	ui_gA_f();
	if (t52_ui == 0x80000000) {
	    ui_gA_d();
	    if (t52_ui != 0x80000000)	print("error %d\n", __LINE__);
	    ui_gA_v();
	    if (t52_ui != 0x7fffffff)	print("error %d\n", __LINE__);
	}
	else if (t52_ui == 0x7fffffff) {
	    ui_gA_d();
	    if (t52_ui != 0x7fffffff)	print("error %d\n", __LINE__);
	    ui_gA_v();
	    if (t52_ui != 0x7ffffffe)	print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	l_gA_i();
	if (t52_l != -0x7fffffff80000002)print("error %d\n", __LINE__);
	l_gA_ui();
	if (t52_l != -0x7fffffff00000001)print("error %d\n", __LINE__);
	l_gA_l();
	if (t52_l !=  0x00000000fffffffe)print("error %d\n", __LINE__);
	l_gA_ul();
	if (t52_l != -0x7fffffff00000001)print("error %d\n", __LINE__);
	l_gA_f();
	if (t52_l != -0x7fffffff00000000)print("error %d\n", __LINE__);
	l_gA_d();
	if (t52_l != -0x7ffffffeff000000)print("error %d\n", __LINE__);
	l_gA_v();
	if (t52_l !=  0x1000000100ffffff)print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	ul_gA_i();
	if (t52_ul != 0x8000000080000000)print("error %d\n", __LINE__);
	ul_gA_ui();
	if (t52_ul != 0x8000000100000001)print("error %d\n", __LINE__);
	ul_gA_l();
	if (t52_ul != 0x0000000100000000)print("error %d\n", __LINE__);
	ul_gA_ul();
	if (t52_ul != 0x8000000100000001)print("error %d\n", __LINE__);
	ul_gA_f();
	if (t52_ul == 0x8000000000000000) {
	    ul_gA_d();
	    if (t52_ul != 0x8000000000000000)print("error %d\n", __LINE__);
	    ul_gA_v();
	    if (t52_ul != 0x0fffffffffffffff)print("error %d\n", __LINE__);
	}
	else if (t52_ul == 0x8000000100000000) {
	    ul_gA_d();
	    if (t52_ul != 0x8000000101000000)print("error %d\n", __LINE__);
	    ul_gA_v();
	    if (t52_ul != 0x1000000100ffffff)print("error %d\n", __LINE__);
	}
	else				print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	f_gA_i();
	if (t52_f != 0x00000000080000100.0)print("error %d\n", __LINE__);
	f_gA_ui();
	if (t52_f != 0x00000000100000200.0)print("error %d\n", __LINE__);
	f_gA_l();
	if (t52_f != 0x08000000000000000.0)print("error %d\n", __LINE__);
	f_gA_ul();
	if (t52_f != 0x10000000000000000.0)print("error %d\n", __LINE__);
	f_gA_f();
	if (t52_f != 0x10000000000000000.0)print("error %d\n", __LINE__);
	f_gA_d();
	if (t52_f != 0x10000000000000000.0)print("error %d\n", __LINE__);
	f_gA_v();
	if (t52_f != 0x19000000000000000.0)print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	d_gA_i();
	if (t52_d != 0x00000000080ffffff.0)print("error %d\n", __LINE__);
	d_gA_ui();
	if (t52_d != 0x00000000101000000.0)print("error %d\n", __LINE__);
	d_gA_l();
	if (t52_d != 0x08000000101000000.0)print("error %d\n", __LINE__);
	d_gA_ul();
	if (t52_d != 0x10000000101000000.0)print("error %d\n", __LINE__);
	d_gA_f();
	if (t52_d != 0x10000000101000000.0)print("error %d\n", __LINE__);
	d_gA_d();
	if (t52_d != 0x10000000102000000.0)print("error %d\n", __LINE__);
	d_gA_v();
	if (t52_d != 0x19000000102000000.0)print("error %d\n", __LINE__);
	i = t52_i = xi;		ui = t52_ui = xui;
	l = t52_l = xl;		ul = t52_ul = xul;
	f = t52_f = xf;		d = t52_d = xd;
	v = t52_v = xv;
	v_gA_i();
	if (t52_v != 0x0900000007ffffffe  )print("error %d\n", __LINE__);
	v_gA_ui();
	if (t52_v != 0x090000000ffffffff  )print("error %d\n", __LINE__);
	v_gA_l();
	if (t52_v != 0x110000000fffffffe  )print("error %d\n", __LINE__);
	v_gA_ul();
	if (t52_v != 0x190000000ffffffff  )print("error %d\n", __LINE__);
	v_gA_f();
	if (t52_v != 0x190000000fffff000.0)print("error %d\n", __LINE__);
	v_gA_d();
	if (t52_v != 0x19000000100fff000.0)print("error %d\n", __LINE__);
	v_gA_v();
	if (t52_v != 0x22000000100ffe000.0)print("error %d\n", __LINE__);
    }
    void t1() {
	x7f();
	i_I_i();
	if (i != -0x80000000)		print("error %d\n", __LINE__);
	i_I_ui();
	if (i != -0x80000000)		print("error %d\n", __LINE__);
	i_I_l();
	if (i !=  0)			print("error %d\n", __LINE__);
	i_I_ul();
	if (i !=  0)			print("error %d\n", __LINE__);
	i_I_f();
	if (i !=  0x80)			print("error %d\n", __LINE__);
	i_I_d();
	if (i !=  0x8000)		print("error %d\n", __LINE__);
	i_I_v();
	if (i !=  0x00000000)		print("error %d\n", __LINE__);
	x7f();
	ui_I_i();
	if (ui != 0x80000000)		print("error %d\n", __LINE__);
	x7f();
	ui_I_ui();
	if (ui != 0x80000000)		print("error %d\n", __LINE__);
	ui_I_l();
	if (ui != 0)			print("error %d\n", __LINE__);
	ui_I_ul();
	if (ui != 0)			print("error %d\n", __LINE__);
	ui_I_f();
	if (ui != 0x80)			print("error %d\n", __LINE__);
	ui_I_d();
	if (ui != 0x8000)		print("error %d\n", __LINE__);
	ui_I_v();
	if (ui != 0)			print("error %d\n", __LINE__);
	x7f();
	l_I_i();
	if (l !=  0x80000000)		print("error %d\n", __LINE__);
	l_I_ui();
	if (l !=  0x80000000)		print("error %d\n", __LINE__);
	x7f();
	l_I_l();
	if (l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_I_ul();
	if (l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_I_f();
	if (l !=  0x80)			print("error %d\n", __LINE__);
	l_I_d();
	if (l !=  0x8000)		print("error %d\n", __LINE__);
	l_I_v();
	if (l !=  0)			print("error %d\n", __LINE__);
	x7f();
	ul_I_i();
	if (ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_I_ui();
	if (ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_I_l();
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	x7f();
	ul_I_ul();
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_I_f();
	if (ul != 0x80)			print("error %d\n", __LINE__);
	ul_I_d();
	if (ul != 0x8000)		print("error %d\n", __LINE__);
	ul_I_v();
	if (ul != 0)		print("error %d\n", __LINE__);
	x7f();
	f_I_i();
	if (f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_I_ui();
	if (f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_I_l();
	if (f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	f_I_ul();
	if (f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	x7f();
	f_I_f();
	if (f != 0x80.0)		print("error %d\n", __LINE__);
	f_I_d();
	if (f != 0x8000.0)		print("error %d\n", __LINE__);
	f_I_v();
	if (f != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	x7f();
	d_I_i();
	if (d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_I_ui();
	if (d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_I_l();
	if (d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_I_ul();
	if (d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_I_f();
	if (d != 0x80.0)		print("error %d\n", __LINE__);
	x7f();
	d_I_d();
	if (d != 0x8000.0)		print("error %d\n", __LINE__);
	d_I_v();
	if (d != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	x7f();
	v_I_i();
	if (v != 0x80000000)		print("error %d\n", __LINE__);
	v_I_ui();
	if (v != 0x80000000)		print("error %d\n", __LINE__);
	v_I_l();
	if (v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_I_ul();
	if (v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_I_f();
	if (v != 0x80.0)		print("error %d\n", __LINE__);
	v_I_d();
	if (v != 0x8000.0)		print("error %d\n", __LINE__);
	x7f();
	v_I_v();
	if (v != 0x800000000000000000000000)
	    print("error %d\n", __LINE__);
	i_Ig_i();
	if (i != -0x80000000)		print("error %d\n", __LINE__);
	i_Ig_ui();
	if (i != -0x80000000)		print("error %d\n", __LINE__);
	i_Ig_l();
	if (i !=  0)			print("error %d\n", __LINE__);
	i_Ig_ul();
	if (i !=  0)			print("error %d\n", __LINE__);
	i_Ig_f();
	if (i !=  0x80)			print("error %d\n", __LINE__);
	i_Ig_d();
	if (i !=  0x8000)		print("error %d\n", __LINE__);
	i_Ig_v();
	if (i !=  0x00000000)		print("error %d\n", __LINE__);
	ui_Ig_i();
	if (ui != 0x80000000)		print("error %d\n", __LINE__);
	ui_Ig_ui();
	if (ui != 0x80000000)		print("error %d\n", __LINE__);
	ui_Ig_l();
	if (ui != 0)			print("error %d\n", __LINE__);
	ui_Ig_ul();
	if (ui != 0)			print("error %d\n", __LINE__);
	ui_Ig_f();
	if (ui != 0x80)			print("error %d\n", __LINE__);
	ui_Ig_d();
	if (ui != 0x8000)		print("error %d\n", __LINE__);
	ui_Ig_v();
	if (ui != 0)			print("error %d\n", __LINE__);
	l_Ig_i();
	if (l !=  0x80000000)		print("error %d\n", __LINE__);
	l_Ig_ui();
	if (l !=  0x80000000)		print("error %d\n", __LINE__);
	l_Ig_l();
	if (l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_Ig_ul();
	if (l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_Ig_f();
	if (l !=  0x80)			print("error %d\n", __LINE__);
	l_Ig_d();
	if (l !=  0x8000)		print("error %d\n", __LINE__);
	l_Ig_v();
	if (l !=  0)			print("error %d\n", __LINE__);
	ul_Ig_i();
	if (ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_Ig_ui();
	if (ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_Ig_l();
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_Ig_ul();
	if (ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_Ig_f();
	if (ul != 0x80)			print("error %d\n", __LINE__);
	ul_Ig_d();
	if (ul != 0x8000)		print("error %d\n", __LINE__);
	ul_Ig_v();
	if (ul != 0)		print("error %d\n", __LINE__);
	f_Ig_i();
	if (f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_Ig_ui();
	if (f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_Ig_l();
	if (f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	f_Ig_ul();
	if (f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	f_Ig_f();
	if (f != 0x80.0)		print("error %d\n", __LINE__);
	f_Ig_d();
	if (f != 0x8000.0)		print("error %d\n", __LINE__);
	f_Ig_v();
	if (f != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	d_Ig_i();
	if (d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_Ig_ui();
	if (d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_Ig_l();
	if (d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_Ig_ul();
	if (d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_Ig_f();
	if (d != 0x80.0)		print("error %d\n", __LINE__);
	d_Ig_d();
	if (d != 0x8000.0)		print("error %d\n", __LINE__);
	d_Ig_v();
	if (d != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	v_Ig_i();
	if (v != 0x80000000)		print("error %d\n", __LINE__);
	v_Ig_ui();
	if (v != 0x80000000)		print("error %d\n", __LINE__);
	v_Ig_l();
	if (v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_Ig_ul();
	if (v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_Ig_f();
	if (v != 0x80.0)		print("error %d\n", __LINE__);
	v_Ig_d();
	if (v != 0x8000.0)		print("error %d\n", __LINE__);
	v_Ig_v();
	if (v != 0x800000000000000000000000)
	    print("error %d\n", __LINE__);
	x7f();
	i_gI_i();
	if (t52_i != -0x80000000)	print("error %d\n", __LINE__);
	i_gI_ui();
	if (t52_i != -0x80000000)	print("error %d\n", __LINE__);
	i_gI_l();
	if (t52_i !=  0)		print("error %d\n", __LINE__);
	i_gI_ul();
	if (t52_i !=  0)		print("error %d\n", __LINE__);
	i_gI_f();
	if (t52_i !=  0x80)		print("error %d\n", __LINE__);
	i_gI_d();
	if (t52_i !=  0x8000)		print("error %d\n", __LINE__);
	i_gI_v();
	if (t52_i !=  0x00000000)	print("error %d\n", __LINE__);
	ui_gI_i();
	if (t52_ui != 0x80000000)	print("error %d\n", __LINE__);
	ui_gI_ui();
	if (t52_ui != 0x80000000)	print("error %d\n", __LINE__);
	ui_gI_l();
	if (t52_ui != 0)		print("error %d\n", __LINE__);
	ui_gI_ul();
	if (t52_ui != 0)		print("error %d\n", __LINE__);
	ui_gI_f();
	if (t52_ui != 0x80)		print("error %d\n", __LINE__);
	ui_gI_d();
	if (t52_ui != 0x8000)		print("error %d\n", __LINE__);
	ui_gI_v();
	if (t52_ui != 0)		print("error %d\n", __LINE__);
	l_gI_i();
	if (t52_l !=  0x80000000)		print("error %d\n", __LINE__);
	l_gI_ui();
	if (t52_l !=  0x80000000)		print("error %d\n", __LINE__);
	l_gI_l();
	if (t52_l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_gI_ul();
	if (t52_l != -0x8000000000000000)	print("error %d\n", __LINE__);
	l_gI_f();
	if (t52_l !=  0x80)			print("error %d\n", __LINE__);
	l_gI_d();
	if (t52_l !=  0x8000)			print("error %d\n", __LINE__);
	l_gI_v();
	if (t52_l !=  0)			print("error %d\n", __LINE__);
	ul_gI_i();
	if (t52_ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_gI_ui();
	if (t52_ul != 0x80000000)		print("error %d\n", __LINE__);
	ul_gI_l();
	if (t52_ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_gI_ul();
	if (t52_ul != 0x8000000000000000)	print("error %d\n", __LINE__);
	ul_gI_f();
	if (t52_ul != 0x80)			print("error %d\n", __LINE__);
	ul_gI_d();
	if (t52_ul != 0x8000)			print("error %d\n", __LINE__);
	ul_gI_v();
	if (t52_ul != 0)			print("error %d\n", __LINE__);
	f_gI_i();
	if (t52_f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_gI_ui();
	if (t52_f != 0x80000000.0)		print("error %d\n", __LINE__);
	f_gI_l();
	if (t52_f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	f_gI_ul();
	if (t52_f != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	f_gI_f();
	if (t52_f != 0x80.0)			print("error %d\n", __LINE__);
	f_gI_d();
	if (t52_f != 0x8000.0)			print("error %d\n", __LINE__);
	f_gI_v();
	if (t52_f != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	d_gI_i();
	if (t52_d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_gI_ui();
	if (t52_d != 0x80000000.0)		print("error %d\n", __LINE__);
	d_gI_l();
	if (t52_d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_gI_ul();
	if (t52_d != 0x8000000000000000.0)	print("error %d\n", __LINE__);
	d_gI_f();
	if (t52_d != 0x80.0)			print("error %d\n", __LINE__);
	d_gI_d();
	if (t52_d != 0x8000.0)			print("error %d\n", __LINE__);
	d_gI_v();
	if (t52_d != 0x800000000000000000000000.0)
	    print("error %d\n", __LINE__);
	v_gI_i();
	if (t52_v != 0x80000000)		print("error %d\n", __LINE__);
	v_gI_ui();
	if (t52_v != 0x80000000)		print("error %d\n", __LINE__);
	v_gI_l();
	if (t52_v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_gI_ul();
	if (t52_v != 0x8000000000000000)	print("error %d\n", __LINE__);
	v_gI_f();
	if (t52_v != 0x80.0)			print("error %d\n", __LINE__);
	v_gI_d();
	if (t52_v != 0x8000.0)			print("error %d\n", __LINE__);
	v_gI_v();
	if (t52_v != 0x800000000000000000000000)
	    print("error %d\n", __LINE__);
    }
    void t2(int32_t i7f, uint32_t ui7f,	int64_t l7f, uint64_t ul7f,
	    float32_t f7f, float64_t d7f, v7f,
	    int32_t i80, uint32_t ui80,	int64_t l80, uint64_t ul80,
	    float32_t f80, float64_t d80, v80,
	    int32_t i81, uint32_t ui81,	int64_t l81, uint64_t ul81,
	    float32_t f81, float64_t d81, v81) {
	int32_t		xi;	uint32_t	xui;
	int64_t		xl;	uint64_t	xul;
	float32_t	xf;	float64_t	xd;
	auto		xv;
	c_x7f();	g_x80();
	if (i != i)		print("error %d\n", __LINE__);
	if (i != ui)		print("error %d\n", __LINE__);
	if (i >= l)		print("error %d\n", __LINE__);
	if (i >= ul)		print("error %d\n", __LINE__);
	if (i <= f)		print("error %d\n", __LINE__);
	if (i <= d)		print("error %d\n", __LINE__);
	if (i >= v)		print("error %d\n", __LINE__);
	if (i != i7f)		print("error %d\n", __LINE__);
	if (i != ui7f)		print("error %d\n", __LINE__);
	if (i >= l7f)		print("error %d\n", __LINE__);
	if (i >= ul7f)		print("error %d\n", __LINE__);
	if (i <= f7f)		print("error %d\n", __LINE__);
	if (i <= d7f)		print("error %d\n", __LINE__);
	if (i >= v7f)		print("error %d\n", __LINE__);
	if (i <= t52_i)		print("error %d\n", __LINE__);
	if (i >= t52_ui)	print("error %d\n", __LINE__);
	if (i <= t52_l)		print("error %d\n", __LINE__);
	if (i >= t52_ul)	print("error %d\n", __LINE__);
	if (i <= t52_f)		print("error %d\n", __LINE__);
	if (i <= t52_d)		print("error %d\n", __LINE__);
	if (i >= t52_v)		print("error %d\n", __LINE__);
	if (i <= i80)		print("error %d\n", __LINE__);
	if (i >= ui80)		print("error %d\n", __LINE__);
	if (i <= l80)		print("error %d\n", __LINE__);
	if (i >= ul80)		print("error %d\n", __LINE__);
	if (i <= f80)		print("error %d\n", __LINE__);
	if (i <= d80)		print("error %d\n", __LINE__);
	if (i >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (i != i)		print("error %d\n", __LINE__);
	if (i == ui)		print("error %d\n", __LINE__);
	if (i <= l)		print("error %d\n", __LINE__);
	if (i >= ul)		print("error %d\n", __LINE__);
	if (i >= f)		print("error %d\n", __LINE__);
	if (i >= d)		print("error %d\n", __LINE__);
	if (i >= v)		print("error %d\n", __LINE__);
	if (i != i80)		print("error %d\n", __LINE__);
	if (i == ui80)		print("error %d\n", __LINE__);
	if (i <= l80)		print("error %d\n", __LINE__);
	if (i >= ul80)		print("error %d\n", __LINE__);
	if (i >= f80)		print("error %d\n", __LINE__);
	if (i >= d80)		print("error %d\n", __LINE__);
	if (i >= v80)		print("error %d\n", __LINE__);
	if (i >= t52_i)		print("error %d\n", __LINE__);
	if (i >= t52_ui)	print("error %d\n", __LINE__);
	if (i <= t52_l)		print("error %d\n", __LINE__);
	if (i >= t52_ul)	print("error %d\n", __LINE__);
	if (i >= t52_f)		print("error %d\n", __LINE__);
	if (i >= t52_d)		print("error %d\n", __LINE__);
	if (i >= t52_v)		print("error %d\n", __LINE__);
	if (i >= i81)		print("error %d\n", __LINE__);
	if (i >= ui81)		print("error %d\n", __LINE__);
	if (i <= l81)		print("error %d\n", __LINE__);
	if (i >= ul81)		print("error %d\n", __LINE__);
	if (i >= f81)		print("error %d\n", __LINE__);
	if (i >= d81)		print("error %d\n", __LINE__);
	if (i >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (ui != i)		print("error %d\n", __LINE__);
	if (ui != ui)		print("error %d\n", __LINE__);
	if (ui >= l)		print("error %d\n", __LINE__);
	if (ui >= ul)		print("error %d\n", __LINE__);
	if (ui <= f)		print("error %d\n", __LINE__);
	if (ui <= d)		print("error %d\n", __LINE__);
	if (ui >= v)		print("error %d\n", __LINE__);
	if (ui != i7f)		print("error %d\n", __LINE__);
	if (ui != ui7f)		print("error %d\n", __LINE__);
	if (ui >= l7f)		print("error %d\n", __LINE__);
	if (ui >= ul7f)		print("error %d\n", __LINE__);
	if (ui <= f7f)		print("error %d\n", __LINE__);
	if (ui <= d7f)		print("error %d\n", __LINE__);
	if (ui >= v7f)		print("error %d\n", __LINE__);
	if (ui <= t52_i)	print("error %d\n", __LINE__);
	if (ui >= t52_ui)	print("error %d\n", __LINE__);
	if (ui <= t52_l)	print("error %d\n", __LINE__);
	if (ui >= t52_ul)	print("error %d\n", __LINE__);
	if (ui <= t52_f)	print("error %d\n", __LINE__);
	if (ui <= t52_d)	print("error %d\n", __LINE__);
	if (ui >= t52_v)	print("error %d\n", __LINE__);
	if (ui <= i80)		print("error %d\n", __LINE__);
	if (ui >= ui80)		print("error %d\n", __LINE__);
	if (ui <= l80)		print("error %d\n", __LINE__);
	if (ui >= ul80)		print("error %d\n", __LINE__);
	if (ui <= f80)		print("error %d\n", __LINE__);
	if (ui <= d80)		print("error %d\n", __LINE__);
	if (ui >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (ui == i)		print("error %d\n", __LINE__);
	if (ui != ui)		print("error %d\n", __LINE__);
	if (ui <= l)		print("error %d\n", __LINE__);
	if (ui >= ul)		print("error %d\n", __LINE__);
	if (ui <= f)		print("error %d\n", __LINE__);
	if (ui <= d)		print("error %d\n", __LINE__);
	if (ui >= v)		print("error %d\n", __LINE__);
	if (ui == i80)		print("error %d\n", __LINE__);
	if (ui != ui80)		print("error %d\n", __LINE__);
	if (ui <= l80)		print("error %d\n", __LINE__);
	if (ui >= ul80)		print("error %d\n", __LINE__);
	if (ui <= f80)		print("error %d\n", __LINE__);
	if (ui <= d80)		print("error %d\n", __LINE__);
	if (ui >= v80)		print("error %d\n", __LINE__);
	if (ui <= t52_i)	print("error %d\n", __LINE__);
	if (ui >= t52_ui)	print("error %d\n", __LINE__);
	if (ui <= t52_l)	print("error %d\n", __LINE__);
	if (ui >= t52_ul)	print("error %d\n", __LINE__);
	if (ui <= t52_f)	print("error %d\n", __LINE__);
	if (ui <= t52_d)	print("error %d\n", __LINE__);
	if (ui >= t52_v)	print("error %d\n", __LINE__);
	if (ui <= i81)		print("error %d\n", __LINE__);
	if (ui >= ui81)		print("error %d\n", __LINE__);
	if (ui <= l81)		print("error %d\n", __LINE__);
	if (ui >= ul81)		print("error %d\n", __LINE__);
	if (ui <= f81)		print("error %d\n", __LINE__);
	if (ui <= d81)		print("error %d\n", __LINE__);
	if (ui >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (l <= i)		print("error %d\n", __LINE__);
	if (l <= ui)		print("error %d\n", __LINE__);
	if (l != l)		print("error %d\n", __LINE__);
	if (l > ul)		print("error %d\n", __LINE__);
	if (l <= f)		print("error %d\n", __LINE__);
	if (l <= d)		print("error %d\n", __LINE__);
	if (l >= v)		print("error %d\n", __LINE__);
	if (l <= i7f)		print("error %d\n", __LINE__);
	if (l <= ui7f)		print("error %d\n", __LINE__);
	if (l != l7f)		print("error %d\n", __LINE__);
	if (l > ul7f)		print("error %d\n", __LINE__);
	if (l <= f7f)		print("error %d\n", __LINE__);
	if (l <= d7f)		print("error %d\n", __LINE__);
	if (l >= v7f)		print("error %d\n", __LINE__);
	if (l <= t52_i)		print("error %d\n", __LINE__);
	if (l <= t52_ui)	print("error %d\n", __LINE__);
	if (l <= t52_l)		print("error %d\n", __LINE__);
	if (l >= t52_ul)	print("error %d\n", __LINE__);
	if (l <= t52_f)		print("error %d\n", __LINE__);
	if (l <= t52_d)		print("error %d\n", __LINE__);
	if (l >= t52_v)		print("error %d\n", __LINE__);
	if (l <= i80)		print("error %d\n", __LINE__);
	if (l <= ui80)		print("error %d\n", __LINE__);
	if (l <= l80)		print("error %d\n", __LINE__);
	if (l >= ul80)		print("error %d\n", __LINE__);
	if (l <= f80)		print("error %d\n", __LINE__);
	if (l <= d80)		print("error %d\n", __LINE__);
	if (l >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (l >= i)		print("error %d\n", __LINE__);
	if (l >= ui)		print("error %d\n", __LINE__);
	if (l != l)		print("error %d\n", __LINE__);
	if (l >= ul)		print("error %d\n", __LINE__);
	if (l >= f)		print("error %d\n", __LINE__);
	if (l >= d)		print("error %d\n", __LINE__);
	if (l >= v)		print("error %d\n", __LINE__);
	if (l >= i80)		print("error %d\n", __LINE__);
	if (l == ui80)		print("error %d\n", __LINE__);
	if (l != l80)		print("error %d\n", __LINE__);
	if (l >= ul80)		print("error %d\n", __LINE__);
	if (l >= f80)		print("error %d\n", __LINE__);
	if (l >= d80)		print("error %d\n", __LINE__);
	if (l >= v80)		print("error %d\n", __LINE__);
	if (l >= t52_i)		print("error %d\n", __LINE__);
	if (l >= t52_ui)	print("error %d\n", __LINE__);
	if (l >= t52_l)		print("error %d\n", __LINE__);
	if (l >= t52_ul)	print("error %d\n", __LINE__);
	if (l >= t52_f)		print("error %d\n", __LINE__);
	if (l >= t52_d)		print("error %d\n", __LINE__);
	if (l >= t52_v)		print("error %d\n", __LINE__);
	if (l >= i81)		print("error %d\n", __LINE__);
	if (l >= ui81)		print("error %d\n", __LINE__);
	if (l >= l81)		print("error %d\n", __LINE__);
	if (l >= ul81)		print("error %d\n", __LINE__);
	if (l >= f81)		print("error %d\n", __LINE__);
	if (l >= d81)		print("error %d\n", __LINE__);
	if (l >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (ul <= i)		print("error %d\n", __LINE__);
	if (ul <= ui)		print("error %d\n", __LINE__);
	if (ul != l)		print("error %d\n",__LINE__);
	if (ul != ul)		print("error %d\n", __LINE__);
	if (ul <= f)		print("error %d\n", __LINE__);
	if (ul <= d)		print("error %d\n", __LINE__);
	if (ul >= v)		print("error %d\n", __LINE__);
	if (ul <= i7f)		print("error %d\n", __LINE__);
	if (ul <= ui7f)		print("error %d\n", __LINE__);
	if (ul != l7f)		print("error %d\n", __LINE__);
	if (ul != ul7f)		print("error %d\n", __LINE__);
	if (ul <= f7f)		print("error %d\n", __LINE__);
	if (ul <= d7f)		print("error %d\n", __LINE__);
	if (ul >= v7f)		print("error %d\n", __LINE__);
	if (ul <= t52_i)	print("error %d\n", __LINE__);
	if (ul <= t52_ui)	print("error %d\n", __LINE__);
	if (ul <= t52_l)	print("error %d\n", __LINE__);
	if (ul >= t52_ul)	print("error %d\n", __LINE__);
	if (ul <= t52_f)	print("error %d\n", __LINE__);
	if (ul <= t52_d)	print("error %d\n", __LINE__);
	if (ul >= t52_v)	print("error %d\n", __LINE__);
	if (ul <= i80)		print("error %d\n", __LINE__);
	if (ul <= ui80)		print("error %d\n", __LINE__);
	if (ul <= l80)		print("error %d\n", __LINE__);
	if (ul >= ul80)		print("error %d\n", __LINE__);
	if (ul <= f80)		print("error %d\n", __LINE__);
	if (ul <= d80)		print("error %d\n", __LINE__);
	if (ul >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (ul == i)		print("error %d\n", __LINE__);
	if (ul == ui)		print("error %d\n", __LINE__);
	if (ul <= l)		print("error %d\n", __LINE__);
	if (ul != ul)		print("error %d\n", __LINE__);
	if (ul <= f)		print("error %d\n", __LINE__);
	if (ul <= d)		print("error %d\n", __LINE__);
	if (ul >= v)		print("error %d\n", __LINE__);
	if (ul == i80)		print("error %d\n", __LINE__);
	if (ul == ui80)		print("error %d\n", __LINE__);
	if (ul <= l80)		print("error %d\n", __LINE__);
	if (ul != ul80)		print("error %d\n", __LINE__);
	if (ul <= f80)		print("error %d\n", __LINE__);
	if (ul <= d80)		print("error %d\n", __LINE__);
	if (ul >= v80)		print("error %d\n", __LINE__);
	if (ul <= t52_i)	print("error %d\n", __LINE__);
	if (ul < t52_ui)	print("error %d\n", __LINE__);
	if (ul <= t52_l)	print("error %d\n", __LINE__);
	if (ul >= t52_ul)	print("error %d\n", __LINE__);
	if (ul <= t52_f)	print("error %d\n", __LINE__);
	if (ul <= t52_d)	print("error %d\n", __LINE__);
	if (ul >= t52_v)	print("error %d\n", __LINE__);
	if (ul <= i81)		print("error %d\n", __LINE__);
	if (ul < ui81)		print("error %d\n", __LINE__);
	if (ul <= l81)		print("error %d\n", __LINE__);
	if (ul >= ul81)		print("error %d\n", __LINE__);
	if (ul <= f81)		print("error %d\n", __LINE__);
	if (ul <= d81)		print("error %d\n", __LINE__);
	if (ul >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (f > i)		print("error %d\n", __LINE__);
	if (f > ui)		print("error %d\n", __LINE__);
	if (f >= l)		print("error %d\n", __LINE__);
	if (f >= ul)		print("error %d\n", __LINE__);
	if (f != f)		print("error %d\n", __LINE__);
	if (f > d)		print("error %d\n", __LINE__);
	if (f > v)		print("error %d\n", __LINE__);
	if (f > i7f)		print("error %d\n", __LINE__);
	if (f > ui7f)		print("error %d\n", __LINE__);
	if (f >= l7f)		print("error %d\n", __LINE__);
	if (f >= ul7f)		print("error %d\n", __LINE__);
	if (f != f7f)		print("error %d\n", __LINE__);
	if (f > d7f)		print("error %d\n", __LINE__);
	if (f > v7f)		print("error %d\n", __LINE__);
	if (f < t52_i)		print("error %d\n", __LINE__);
	if (f > t52_ui)		print("error %d\n", __LINE__);
	if (f < t52_l)		print("error %d\n", __LINE__);
	if (f > t52_ul)		print("error %d\n", __LINE__);
	if (f > t52_f)		print("error %d\n", __LINE__);
	if (f > t52_d)		print("error %d\n", __LINE__);
	if (f > t52_v)		print("error %d\n", __LINE__);
	if (f < i80)		print("error %d\n", __LINE__);
	if (f > ui80)		print("error %d\n", __LINE__);
	if (f < l80)		print("error %d\n", __LINE__);
	if (f > ul80)		print("error %d\n", __LINE__);
	if (f > f80)		print("error %d\n", __LINE__);
	if (f > d80)		print("error %d\n", __LINE__);
	if (f > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (f < i)		print("error %d\n", __LINE__);
	if (f > ui)		print("error %d\n", __LINE__);
	if (f < l)		print("error %d\n", __LINE__);
	if (f >= ul)		print("error %d\n", __LINE__);
	if (f != f)		print("error %d\n", __LINE__);
	if (f >= d)		print("error %d\n", __LINE__);
	if (f >= v)		print("error %d\n", __LINE__);
	if (f < i80)		print("error %d\n", __LINE__);
	if (f > ui80)		print("error %d\n", __LINE__);
	if (f < l80)		print("error %d\n", __LINE__);
	if (f >= ul80)		print("error %d\n", __LINE__);
	if (f != f80)		print("error %d\n", __LINE__);
	if (f >= d80)		print("error %d\n", __LINE__);
	if (f >= v80)		print("error %d\n", __LINE__);
	if (f < t52_i)		print("error %d\n", __LINE__);
	if (f >= t52_ui)	print("error %d\n", __LINE__);
	if (f < t52_l)		print("error %d\n", __LINE__);
	if (f >= t52_ul)	print("error %d\n", __LINE__);
	if (f >= t52_f)		print("error %d\n", __LINE__);
	if (f >= t52_d)		print("error %d\n", __LINE__);
	if (f >= t52_v)		print("error %d\n", __LINE__);
	if (f < i81)		print("error %d\n", __LINE__);
	if (f >= ui81)		print("error %d\n", __LINE__);
	if (f < l81)		print("error %d\n", __LINE__);
	if (f >= ul81)		print("error %d\n", __LINE__);
	if (f >= f81)		print("error %d\n", __LINE__);
	if (f >= d81)		print("error %d\n", __LINE__);
	if (f >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (d > i)		print("error %d\n", __LINE__);
	if (d > ui)		print("error %d\n", __LINE__);
	if (d >= l)		print("error %d\n", __LINE__);
	if (d >= ul)		print("error %d\n", __LINE__);
	if (d <= f)		print("error %d\n", __LINE__);
	if (d != d)		print("error %d\n", __LINE__);
	if (d > v)		print("error %d\n", __LINE__);
	if (d > i7f)		print("error %d\n", __LINE__);
	if (d > ui7f)		print("error %d\n", __LINE__);
	if (d >= l7f)		print("error %d\n", __LINE__);
	if (d >= ul7f)		print("error %d\n", __LINE__);
	if (d <= f7f)		print("error %d\n", __LINE__);
	if (d != d7f)		print("error %d\n", __LINE__);
	if (d > v7f)		print("error %d\n", __LINE__);
	if (d < t52_i)		print("error %d\n", __LINE__);
	if (d > t52_ui)		print("error %d\n", __LINE__);
	if (d < t52_l)		print("error %d\n", __LINE__);
	if (d > t52_ul)		print("error %d\n", __LINE__);
	if (d < t52_f)		print("error %d\n", __LINE__);
	if (d > t52_d)		print("error %d\n", __LINE__);
	if (d > t52_v)		print("error %d\n", __LINE__);
	if (d < i80)		print("error %d\n", __LINE__);
	if (d > ui80)		print("error %d\n", __LINE__);
	if (d < l80)		print("error %d\n", __LINE__);
	if (d > ul80)		print("error %d\n", __LINE__);
	if (d < f80)		print("error %d\n", __LINE__);
	if (d > d80)		print("error %d\n", __LINE__);
	if (d > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (d < i)		print("error %d\n", __LINE__);
	if (d > ui)		print("error %d\n", __LINE__);
	if (d < l)		print("error %d\n", __LINE__);
	if (d >= ul)		print("error %d\n", __LINE__);
	if (d <= f)		print("error %d\n", __LINE__);
	if (d != d)		print("error %d\n", __LINE__);
	if (d >= v)		print("error %d\n", __LINE__);
	if (d < i80)		print("error %d\n", __LINE__);
	if (d > ui80)		print("error %d\n", __LINE__);
	if (d < l80)		print("error %d\n", __LINE__);
	if (d >= ul80)		print("error %d\n", __LINE__);
	if (d <= f80)		print("error %d\n", __LINE__);
	if (d != d80)		print("error %d\n", __LINE__);
	if (d >= v80)		print("error %d\n", __LINE__);
	if (d < t52_i)		print("error %d\n", __LINE__);
	if (d >= t52_ui)	print("error %d\n", __LINE__);
	if (d < t52_l)		print("error %d\n", __LINE__);
	if (d >= t52_ul)	print("error %d\n", __LINE__);
	if (d <= t52_f)		print("error %d\n", __LINE__);
	if (d >= t52_d)		print("error %d\n", __LINE__);
	if (d >= t52_v)		print("error %d\n", __LINE__);
	if (d < i81)		print("error %d\n", __LINE__);
	if (d >= ui81)		print("error %d\n", __LINE__);
	if (d < l81)		print("error %d\n", __LINE__);
	if (d >= ul81)		print("error %d\n", __LINE__);
	if (d <= f81)		print("error %d\n", __LINE__);
	if (d >= d81)		print("error %d\n", __LINE__);
	if (d >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (v < i)		print("error %d\n", __LINE__);
	if (v < ui)		print("error %d\n", __LINE__);
	if (v <= l)		print("error %d\n", __LINE__);
	if (v <= ul)		print("error %d\n", __LINE__);
	if (v <= f)		print("error %d\n", __LINE__);
	if (v <= d)		print("error %d\n", __LINE__);
	if (v != v)		print("error %d\n", __LINE__);
	if (v < i7f)		print("error %d\n", __LINE__);
	if (v < ui7f)		print("error %d\n", __LINE__);
	if (v <= l7f)		print("error %d\n", __LINE__);
	if (v <= ul7f)		print("error %d\n", __LINE__);
	if (v <= f7f)		print("error %d\n", __LINE__);
	if (v <= d7f)		print("error %d\n", __LINE__);
	if (v != v7f)		print("error %d\n", __LINE__);
	if (v < t52_i)		print("error %d\n", __LINE__);
	if (v < t52_ui)		print("error %d\n", __LINE__);
	if (v < t52_l)		print("error %d\n", __LINE__);
	if (v < t52_ul)		print("error %d\n", __LINE__);
	if (v < t52_f)		print("error %d\n", __LINE__);
	if (v < t52_d)		print("error %d\n", __LINE__);
	if (v > t52_v)		print("error %d\n", __LINE__);
	if (v < i80)		print("error %d\n", __LINE__);
	if (v < ui80)		print("error %d\n", __LINE__);
	if (v < l80)		print("error %d\n", __LINE__);
	if (v < ul80)		print("error %d\n", __LINE__);
	if (v < f80)		print("error %d\n", __LINE__);
	if (v < d80)		print("error %d\n", __LINE__);
	if (v > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (v < i)		print("error %d\n", __LINE__);
	if (v < ui)		print("error %d\n", __LINE__);
	if (v < l)		print("error %d\n", __LINE__);
	if (v <= ul)		print("error %d\n", __LINE__);
	if (v <= f)		print("error %d\n", __LINE__);
	if (v <= d)		print("error %d\n", __LINE__);
	if (v != v)		print("error %d\n", __LINE__);
	if (v < i80)		print("error %d\n", __LINE__);
	if (v < ui80)		print("error %d\n", __LINE__);
	if (v < l80)		print("error %d\n", __LINE__);
	if (v <= ul80)		print("error %d\n", __LINE__);
	if (v <= f80)		print("error %d\n", __LINE__);
	if (v <= d80)		print("error %d\n", __LINE__);
	if (v != v80)		print("error %d\n", __LINE__);
	if (v < t52_i)		print("error %d\n", __LINE__);
	if (v <= t52_ui)	print("error %d\n", __LINE__);
	if (v < t52_l)		print("error %d\n", __LINE__);
	if (v <= t52_ul)	print("error %d\n", __LINE__);
	if (v <= t52_f)		print("error %d\n", __LINE__);
	if (v <= t52_d)		print("error %d\n", __LINE__);
	if (v >= t52_v)		print("error %d\n", __LINE__);
	if (v < i81)		print("error %d\n", __LINE__);
	if (v <= ui81)		print("error %d\n", __LINE__);
	if (v < l81)		print("error %d\n", __LINE__);
	if (v <= ul81)		print("error %d\n", __LINE__);
	if (v <= f81)		print("error %d\n", __LINE__);
	if (v <= d81)		print("error %d\n", __LINE__);
	if (v >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (i7f != i)		print("error %d\n", __LINE__);
	if (i7f != ui)		print("error %d\n", __LINE__);
	if (i7f >= l)		print("error %d\n", __LINE__);
	if (i7f >= ul)		print("error %d\n", __LINE__);
	if (i7f <= f)		print("error %d\n", __LINE__);
	if (i7f <= d)		print("error %d\n", __LINE__);
	if (i7f >= v)		print("error %d\n", __LINE__);
	if (i7f <= t52_i)	print("error %d\n", __LINE__);
	if (i7f >= t52_ui)	print("error %d\n", __LINE__);
	if (i7f <= t52_l)	print("error %d\n", __LINE__);
	if (i7f >= t52_ul)	print("error %d\n", __LINE__);
	if (i7f <= t52_f)	print("error %d\n", __LINE__);
	if (i7f <= t52_d)	print("error %d\n", __LINE__);
	if (i7f >= t52_v)	print("error %d\n", __LINE__);
	if (i7f <= i80)		print("error %d\n", __LINE__);
	if (i7f >= ui80)	print("error %d\n", __LINE__);
	if (i7f <= l80)		print("error %d\n", __LINE__);
	if (i7f >= ul80)	print("error %d\n", __LINE__);
	if (i7f <= f80)		print("error %d\n", __LINE__);
	if (i7f <= d80)		print("error %d\n", __LINE__);
	if (i7f >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (i80 != i)		print("error %d\n", __LINE__);
	if (i80 == ui)		print("error %d\n", __LINE__);
	if (i80 <= l)		print("error %d\n", __LINE__);
	if (i80 >= ul)		print("error %d\n", __LINE__);
	if (i80 >= f)		print("error %d\n", __LINE__);
	if (i80 >= d)		print("error %d\n", __LINE__);
	if (i80 >= v)		print("error %d\n", __LINE__);
	if (i80 >= t52_i)	print("error %d\n", __LINE__);
	if (i80 >= t52_ui)	print("error %d\n", __LINE__);
	if (i80 <= t52_l)	print("error %d\n", __LINE__);
	if (i80 >= t52_ul)	print("error %d\n", __LINE__);
	if (i80 >= t52_f)	print("error %d\n", __LINE__);
	if (i80 >= t52_d)	print("error %d\n", __LINE__);
	if (i80 >= t52_v)	print("error %d\n", __LINE__);
	if (i80 >= i81)		print("error %d\n", __LINE__);
	if (i80 >= ui81)	print("error %d\n", __LINE__);
	if (i80 <= l81)		print("error %d\n", __LINE__);
	if (i80 >= ul81)	print("error %d\n", __LINE__);
	if (i80 >= f81)		print("error %d\n", __LINE__);
	if (i80 >= d81)		print("error %d\n", __LINE__);
	if (i80 >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (ui7f != i)		print("error %d\n", __LINE__);
	if (ui7f != ui)		print("error %d\n", __LINE__);
	if (ui7f >= l)		print("error %d\n", __LINE__);
	if (ui7f >= ul)		print("error %d\n", __LINE__);
	if (ui7f <= f)		print("error %d\n", __LINE__);
	if (ui7f <= d)		print("error %d\n", __LINE__);
	if (ui7f >= v)		print("error %d\n", __LINE__);
	if (ui7f <= t52_i)	print("error %d\n", __LINE__);
	if (ui7f >= t52_ui)	print("error %d\n", __LINE__);
	if (ui7f <= t52_l)	print("error %d\n", __LINE__);
	if (ui7f >= t52_ul)	print("error %d\n", __LINE__);
	if (ui7f <= t52_f)	print("error %d\n", __LINE__);
	if (ui7f <= t52_d)	print("error %d\n", __LINE__);
	if (ui7f >= t52_v)	print("error %d\n", __LINE__);
	if (ui7f <= i80)	print("error %d\n", __LINE__);
	if (ui7f >= ui80)	print("error %d\n", __LINE__);
	if (ui7f <= l80)	print("error %d\n", __LINE__);
	if (ui7f >= ul80)	print("error %d\n", __LINE__);
	if (ui7f <= f80)	print("error %d\n", __LINE__);
	if (ui7f <= d80)	print("error %d\n", __LINE__);
	if (ui7f >= v80)	print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (ui80 == i)		print("error %d\n", __LINE__);
	if (ui80 != ui)		print("error %d\n", __LINE__);
	if (ui80 <= l)		print("error %d\n", __LINE__);
	if (ui80 >= ul)		print("error %d\n", __LINE__);
	if (ui80 <= f)		print("error %d\n", __LINE__);
	if (ui80 <= d)		print("error %d\n", __LINE__);
	if (ui80 >= v)		print("error %d\n", __LINE__);
	if (ui80 <= t52_i)	print("error %d\n", __LINE__);
	if (ui80 >= t52_ui)	print("error %d\n", __LINE__);
	if (ui80 <= t52_l)	print("error %d\n", __LINE__);
	if (ui80 >= t52_ul)	print("error %d\n", __LINE__);
	if (ui80 <= t52_f)	print("error %d\n", __LINE__);
	if (ui80 <= t52_d)	print("error %d\n", __LINE__);
	if (ui80 >= t52_v)	print("error %d\n", __LINE__);
	if (ui80 <= i81)	print("error %d\n", __LINE__);
	if (ui80 >= ui81)	print("error %d\n", __LINE__);
	if (ui80 <= l81)	print("error %d\n", __LINE__);
	if (ui80 >= ul81)	print("error %d\n", __LINE__);
	if (ui80 <= f81)	print("error %d\n", __LINE__);
	if (ui80 <= d81)	print("error %d\n", __LINE__);
	if (ui80 >= v81)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (l7f <= i)		print("error %d\n", __LINE__);
	if (l7f <= ui)		print("error %d\n", __LINE__);
	if (l7f != l)		print("error %d\n", __LINE__);
	if (l7f > ul)		print("error %d\n", __LINE__);
	if (l7f <= f)		print("error %d\n", __LINE__);
	if (l7f <= d)		print("error %d\n", __LINE__);
	if (l7f >= v)		print("error %d\n", __LINE__);
	if (l7f <= t52_i)	print("error %d\n", __LINE__);
	if (l7f <= t52_ui)	print("error %d\n", __LINE__);
	if (l7f <= t52_l)	print("error %d\n", __LINE__);
	if (l7f >= t52_ul)	print("error %d\n", __LINE__);
	if (l7f <= t52_f)	print("error %d\n", __LINE__);
	if (l7f <= t52_d)	print("error %d\n", __LINE__);
	if (l7f >= t52_v)	print("error %d\n", __LINE__);
	if (l7f <= i80)		print("error %d\n", __LINE__);
	if (l7f <= ui80)	print("error %d\n", __LINE__);
	if (l7f <= l80)		print("error %d\n", __LINE__);
	if (l7f >= ul80)	print("error %d\n", __LINE__);
	if (l7f <= f80)		print("error %d\n", __LINE__);
	if (l7f <= d80)		print("error %d\n", __LINE__);
	if (l7f >= v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (l80 >= i)		print("error %d\n", __LINE__);
	if (l80 >= ui)		print("error %d\n", __LINE__);
	if (l80 != l)		print("error %d\n", __LINE__);
	if (l80 >= ul)		print("error %d\n", __LINE__);
	if (l80 >= f)		print("error %d\n", __LINE__);
	if (l80 >= d)		print("error %d\n", __LINE__);
	if (l80 >= v)		print("error %d\n", __LINE__);
	if (l80 >= t52_i)	print("error %d\n", __LINE__);
	if (l80 >= t52_ui)	print("error %d\n", __LINE__);
	if (l80 >= t52_l)	print("error %d\n", __LINE__);
	if (l80 >= t52_ul)	print("error %d\n", __LINE__);
	if (l80 >= t52_f)	print("error %d\n", __LINE__);
	if (l80 >= t52_d)	print("error %d\n", __LINE__);
	if (l80 >= t52_v)	print("error %d\n", __LINE__);
	if (l80 >= i81)		print("error %d\n", __LINE__);
	if (l80 >= ui81)	print("error %d\n", __LINE__);
	if (l80 >= l81)		print("error %d\n", __LINE__);
	if (l80 >= ul81)	print("error %d\n", __LINE__);
	if (l80 >= f81)		print("error %d\n", __LINE__);
	if (l80 >= d81)		print("error %d\n", __LINE__);
	if (l80 >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (ul7f <= i)		print("error %d\n", __LINE__);
	if (ul7f <= ui)		print("error %d\n", __LINE__);
	if (ul7f != l)		print("error %d\n",__LINE__);
	if (ul7f != ul)		print("error %d\n", __LINE__);
	if (ul7f <= f)		print("error %d\n", __LINE__);
	if (ul7f <= d)		print("error %d\n", __LINE__);
	if (ul7f >= v)		print("error %d\n", __LINE__);
	if (ul7f <= t52_i)	print("error %d\n", __LINE__);
	if (ul7f <= t52_ui)	print("error %d\n", __LINE__);
	if (ul7f <= t52_l)	print("error %d\n", __LINE__);
	if (ul7f >= t52_ul)	print("error %d\n", __LINE__);
	if (ul7f <= t52_f)	print("error %d\n",__LINE__);
	if (ul7f <= t52_d)	print("error %d\n", __LINE__);
	if (ul7f >= t52_v)	print("error %d\n", __LINE__);
	if (ul7f <= i80)	print("error %d\n", __LINE__);
	if (ul7f <= ui80)	print("error %d\n", __LINE__);
	if (ul7f <= l80)	print("error %d\n", __LINE__);
	if (ul7f >= ul80)	print("error %d\n", __LINE__);
	if (ul7f <= f80)	print("error %d\n", __LINE__);
	if (ul7f <= d80)	print("error %d\n", __LINE__);
	if (ul7f >= v80)	print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (ul80 == i)		print("error %d\n", __LINE__);
	if (ul80 == ui)		print("error %d\n", __LINE__);
	if (ul80 <= l)		print("error %d\n", __LINE__);
	if (ul80 != ul)		print("error %d\n", __LINE__);
	if (ul80 <= f)		print("error %d\n", __LINE__);
	if (ul80 <= d)		print("error %d\n", __LINE__);
	if (ul80 >= v)		print("error %d\n", __LINE__);
	if (ul80 <= t52_i)	print("error %d\n", __LINE__);
	if (ul80 < t52_ui)	print("error %d\n", __LINE__);
	if (ul80 <= t52_l)	print("error %d\n", __LINE__);
	if (ul80 >= t52_ul)	print("error %d\n", __LINE__);
	if (ul80 <= t52_f)	print("error %d\n", __LINE__);
	if (ul80 <= t52_d)	print("error %d\n", __LINE__);
	if (ul80 >= t52_v)	print("error %d\n", __LINE__);
	if (ul80 <= i81)	print("error %d\n", __LINE__);
	if (ul80 < ui81)	print("error %d\n", __LINE__);
	if (ul80 <= l81)	print("error %d\n", __LINE__);
	if (ul80 >= ul81)	print("error %d\n", __LINE__);
	if (ul80 <= f81)	print("error %d\n", __LINE__);
	if (ul80 <= d81)	print("error %d\n", __LINE__);
	if (ul80 >= v81)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (f7f > i)		print("error %d\n", __LINE__);
	if (f7f > ui)		print("error %d\n", __LINE__);
	if (f7f >= l)		print("error %d\n", __LINE__);
	if (f7f >= ul)		print("error %d\n", __LINE__);
	if (f7f != f)		print("error %d\n", __LINE__);
	if (f7f > d)		print("error %d\n", __LINE__);
	if (f7f > v)		print("error %d\n", __LINE__);
	if (f7f < t52_i)	print("error %d\n", __LINE__);
	if (f7f > t52_ui)	print("error %d\n", __LINE__);
	if (f7f < t52_l)	print("error %d\n", __LINE__);
	if (f7f > t52_ul)	print("error %d\n", __LINE__);
	if (f7f > t52_f)	print("error %d\n", __LINE__);
	if (f7f > t52_d)	print("error %d\n", __LINE__);
	if (f7f > t52_v)	print("error %d\n", __LINE__);
	if (f7f < i80)		print("error %d\n", __LINE__);
	if (f7f > ui80)		print("error %d\n", __LINE__);
	if (f7f < l80)		print("error %d\n", __LINE__);
	if (f7f > ul80)		print("error %d\n", __LINE__);
	if (f7f > f80)		print("error %d\n", __LINE__);
	if (f7f > d80)		print("error %d\n", __LINE__);
	if (f7f > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (f80 < i)		print("error %d\n", __LINE__);
	if (f80 > ui)		print("error %d\n", __LINE__);
	if (f80 < l)		print("error %d\n", __LINE__);
	if (f80 >= ul)		print("error %d\n", __LINE__);
	if (f80 != f)		print("error %d\n", __LINE__);
	if (f80 >= d)		print("error %d\n", __LINE__);
	if (f80 >= v)		print("error %d\n", __LINE__);
	if (f80 < t52_i)	print("error %d\n", __LINE__);
	if (f80 >= t52_ui)	print("error %d\n", __LINE__);
	if (f80 < t52_l)	print("error %d\n", __LINE__);
	if (f80 >= t52_ul)	print("error %d\n", __LINE__);
	if (f80 >= t52_f)	print("error %d\n", __LINE__);
	if (f80 >= t52_d)	print("error %d\n", __LINE__);
	if (f80 >= t52_v)	print("error %d\n", __LINE__);
	if (f80 < i81)		print("error %d\n", __LINE__);
	if (f80 >= ui81)	print("error %d\n", __LINE__);
	if (f80 < l81)		print("error %d\n", __LINE__);
	if (f80 >= ul81)	print("error %d\n", __LINE__);
	if (f80 >= f81)		print("error %d\n", __LINE__);
	if (f80 >= d81)		print("error %d\n", __LINE__);
	if (f80 >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (d7f > i)		print("error %d\n", __LINE__);
	if (d7f > ui)		print("error %d\n", __LINE__);
	if (d7f >= l)		print("error %d\n", __LINE__);
	if (d7f >= ul)		print("error %d\n", __LINE__);
	if (d7f <= f)		print("error %d\n", __LINE__);
	if (d7f != d)		print("error %d\n", __LINE__);
	if (d7f > v)		print("error %d\n", __LINE__);
	if (d7f < t52_i)	print("error %d\n", __LINE__);
	if (d7f > t52_ui)	print("error %d\n", __LINE__);
	if (d7f < t52_l)	print("error %d\n", __LINE__);
	if (d7f > t52_ul)	print("error %d\n", __LINE__);
	if (d7f < t52_f)	print("error %d\n", __LINE__);
	if (d7f > t52_d)	print("error %d\n", __LINE__);
	if (d7f > t52_v)	print("error %d\n", __LINE__);
	if (d7f < i80)		print("error %d\n", __LINE__);
	if (d7f > ui80)		print("error %d\n", __LINE__);
	if (d7f < l80)		print("error %d\n", __LINE__);
	if (d7f > ul80)		print("error %d\n", __LINE__);
	if (d7f < f80)		print("error %d\n", __LINE__);
	if (d7f > d80)		print("error %d\n", __LINE__);
	if (d7f > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (d80 < i)		print("error %d\n", __LINE__);
	if (d80 > ui)		print("error %d\n", __LINE__);
	if (d80 < l)		print("error %d\n", __LINE__);
	if (d80 >= ul)		print("error %d\n", __LINE__);
	if (d80 <= f)		print("error %d\n", __LINE__);
	if (d80 != d)		print("error %d\n", __LINE__);
	if (d80 >= v)		print("error %d\n", __LINE__);
	if (d80 < t52_i)	print("error %d\n", __LINE__);
	if (d80 >= t52_ui)	print("error %d\n", __LINE__);
	if (d80 < t52_l)	print("error %d\n", __LINE__);
	if (d80 >= t52_ul)	print("error %d\n", __LINE__);
	if (d80 <= t52_f)	print("error %d\n", __LINE__);
	if (d80 >= t52_d)	print("error %d\n", __LINE__);
	if (d80 >= t52_v)	print("error %d\n", __LINE__);
	if (d80 < i81)		print("error %d\n", __LINE__);
	if (d80 >= ui81)	print("error %d\n", __LINE__);
	if (d80 < l81)		print("error %d\n", __LINE__);
	if (d80 >= ul81)	print("error %d\n", __LINE__);
	if (d80 <= f81)		print("error %d\n", __LINE__);
	if (d80 >= d81)		print("error %d\n", __LINE__);
	if (d80 >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (v7f < i)		print("error %d\n", __LINE__);
	if (v7f < ui)		print("error %d\n", __LINE__);
	if (v7f <= l)		print("error %d\n", __LINE__);
	if (v7f <= ul)		print("error %d\n", __LINE__);
	if (v7f <= f)		print("error %d\n", __LINE__);
	if (v7f <= d)		print("error %d\n", __LINE__);
	if (v7f != v)		print("error %d\n", __LINE__);
	if (v7f < t52_i)	print("error %d\n", __LINE__);
	if (v7f < t52_ui)	print("error %d\n", __LINE__);
	if (v7f < t52_l)	print("error %d\n", __LINE__);
	if (v7f < t52_ul)	print("error %d\n", __LINE__);
	if (v7f < t52_f)	print("error %d\n", __LINE__);
	if (v7f < t52_d)	print("error %d\n", __LINE__);
	if (v7f > t52_v)	print("error %d\n", __LINE__);
	if (v7f < i80)		print("error %d\n", __LINE__);
	if (v7f < ui80)		print("error %d\n", __LINE__);
	if (v7f < l80)		print("error %d\n", __LINE__);
	if (v7f < ul80)		print("error %d\n", __LINE__);
	if (v7f < f80)		print("error %d\n", __LINE__);
	if (v7f < d80)		print("error %d\n", __LINE__);
	if (v7f > v80)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (v80 < i)		print("error %d\n", __LINE__);
	if (v80 < ui)		print("error %d\n", __LINE__);
	if (v80 < l)		print("error %d\n", __LINE__);
	if (v80 <= ul)		print("error %d\n", __LINE__);
	if (v80 <= f)		print("error %d\n", __LINE__);
	if (v80 <= d)		print("error %d\n", __LINE__);
	if (v80 != v)		print("error %d\n", __LINE__);
	if (v80 < t52_i)	print("error %d\n", __LINE__);
	if (v80 <= t52_ui)	print("error %d\n", __LINE__);
	if (v80 < t52_l)	print("error %d\n", __LINE__);
	if (v80 <= t52_ul)	print("error %d\n", __LINE__);
	if (v80 <= t52_f)	print("error %d\n", __LINE__);
	if (v80 <= t52_d)	print("error %d\n", __LINE__);
	if (v80 >= t52_v)	print("error %d\n", __LINE__);
	if (v80 < i81)		print("error %d\n", __LINE__);
	if (v80 <= ui81)	print("error %d\n", __LINE__);
	if (v80 < l81)		print("error %d\n", __LINE__);
	if (v80 <= ul81)	print("error %d\n", __LINE__);
	if (v80 <= f81)		print("error %d\n", __LINE__);
	if (v80 <= d81)		print("error %d\n", __LINE__);
	if (v80 >= v81)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_i > i)		print("error %d\n", __LINE__);
	if (t52_i > ui)		print("error %d\n", __LINE__);
	if (t52_i > l)		print("error %d\n", __LINE__);
	if (t52_i > ul)		print("error %d\n", __LINE__);
	if (t52_i > f)		print("error %d\n", __LINE__);
	if (t52_i > d)		print("error %d\n", __LINE__);
	if (t52_i > v)		print("error %d\n", __LINE__);
	if (t52_i > i7f)	print("error %d\n", __LINE__);
	if (t52_i > ui7f)	print("error %d\n", __LINE__);
	if (t52_i > l7f)	print("error %d\n", __LINE__);
	if (t52_i > ul7f)	print("error %d\n", __LINE__);
	if (t52_i > f7f)	print("error %d\n", __LINE__);
	if (t52_i > d7f)	print("error %d\n", __LINE__);
	if (t52_i > v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_ui < i)		print("error %d\n", __LINE__);
	if (t52_ui == ui)	print("error %d\n", __LINE__);
	if (t52_ui > l)		print("error %d\n", __LINE__);
	if (t52_ui > ul)	print("error %d\n", __LINE__);
	if (t52_ui < f)		print("error %d\n", __LINE__);
	if (t52_ui < d)		print("error %d\n", __LINE__);
	if (t52_ui > v)		print("error %d\n", __LINE__);
	if (t52_ui == i7f)	print("error %d\n", __LINE__);
	if (t52_ui == ui7f)	print("error %d\n", __LINE__);
	if (t52_ui > l7f)	print("error %d\n", __LINE__);
	if (t52_ui > ul7f)	print("error %d\n", __LINE__);
	if (t52_ui < f7f)	print("error %d\n", __LINE__);
	if (t52_ui < d7f)	print("error %d\n", __LINE__);
	if (t52_ui > v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_l > i)		print("error %d\n", __LINE__);
	if (t52_l > ui)		print("error %d\n", __LINE__);
	if (t52_l == l)		print("error %d\n", __LINE__);
	if (t52_l > ul)		print("error %d\n", __LINE__);
	if (t52_l > f)		print("error %d\n", __LINE__);
	if (t52_l > d)		print("error %d\n", __LINE__);
	if (t52_l > v)		print("error %d\n", __LINE__);
	if (t52_l > i7f)	print("error %d\n", __LINE__);
	if (t52_l > ui7f)	print("error %d\n", __LINE__);
	if (t52_l == l7f)	print("error %d\n", __LINE__);
	if (t52_l > ul7f)	print("error %d\n", __LINE__);
	if (t52_l > f7f)	print("error %d\n", __LINE__);
	if (t52_l > d7f)	print("error %d\n", __LINE__);
	if (t52_l > v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_ul <= i)	print("error %d\n", __LINE__);
	if (t52_ul <= ui)	print("error %d\n", __LINE__);
	if (t52_ul <= l)	print("error %d\n",__LINE__);
	if (t52_ul <= ul)	print("error %d\n", __LINE__);
	if (t52_ul <= f)	print("error %d\n", __LINE__);
	if (t52_ul <= d)	print("error %d\n", __LINE__);
	if (t52_ul >= v)	print("error %d\n", __LINE__);
	if (t52_ul <= i7f)	print("error %d\n", __LINE__);
	if (t52_ul <= ui7f)	print("error %d\n", __LINE__);
	if (t52_ul <= l7f)	print("error %d\n", __LINE__);
	if (t52_ul <= ul7f)	print("error %d\n", __LINE__);
	if (t52_ul <= f7f)	print("error %d\n", __LINE__);
	if (t52_ul <= d7f)	print("error %d\n", __LINE__);
	if (t52_ul >= v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_f > i)		print("error %d\n", __LINE__);
	if (t52_f > ui)		print("error %d\n", __LINE__);
	if (t52_f > l)		print("error %d\n", __LINE__);
	if (t52_f > ul)		print("error %d\n", __LINE__);
	if (t52_f == f)		print("error %d\n", __LINE__);
	if (t52_f > d)		print("error %d\n", __LINE__);
	if (t52_f > v)		print("error %d\n", __LINE__);
	if (t52_f > i7f)	print("error %d\n", __LINE__);
	if (t52_f > ui7f)	print("error %d\n", __LINE__);
	if (t52_f > l7f)	print("error %d\n", __LINE__);
	if (t52_f > ul7f)	print("error %d\n", __LINE__);
	if (t52_f == f7f)	print("error %d\n", __LINE__);
	if (t52_f > d7f)	print("error %d\n", __LINE__);
	if (t52_f > v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_d > i)		print("error %d\n", __LINE__);
	if (t52_d > ui)		print("error %d\n", __LINE__);
	if (t52_d > l)		print("error %d\n", __LINE__);
	if (t52_d > ul)		print("error %d\n", __LINE__);
	if (t52_d <= f)		print("error %d\n", __LINE__);
	if (t52_d <= d)		print("error %d\n", __LINE__);
	if (t52_d > v)		print("error %d\n", __LINE__);
	if (t52_d > i7f)	print("error %d\n", __LINE__);
	if (t52_d > ui7f)	print("error %d\n", __LINE__);
	if (t52_d > l7f)	print("error %d\n", __LINE__);
	if (t52_d > ul7f)	print("error %d\n", __LINE__);
	if (t52_d <= f7f)	print("error %d\n", __LINE__);
	if (t52_d <= d7f)	print("error %d\n", __LINE__);
	if (t52_d > v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_v <= i)		print("error %d\n", __LINE__);
	if (t52_v < ui)		print("error %d\n", __LINE__);
	if (t52_v < l)		print("error %d\n", __LINE__);
	if (t52_v <= ul)	print("error %d\n", __LINE__);
	if (t52_v < f)		print("error %d\n", __LINE__);
	if (t52_v <= d)		print("error %d\n", __LINE__);
	if (t52_v == v)		print("error %d\n", __LINE__);
	if (t52_v <= i7f)	print("error %d\n", __LINE__);
	if (t52_v < ui7f)	print("error %d\n", __LINE__);
	if (t52_v < l7f)	print("error %d\n", __LINE__);
	if (t52_v <= ul7f)	print("error %d\n", __LINE__);
	if (t52_v < f7f)	print("error %d\n", __LINE__);
	if (t52_v <= d7f)	print("error %d\n", __LINE__);
	if (t52_v == v7f)	print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (xi = i != i, xi)		print("error %d\n", __LINE__);
	if (xui = i != ui, xui)		print("error %d\n", __LINE__);
	if (xl = i >= l, xl)		print("error %d\n", __LINE__);
	if (xul = i >= ul, xul)		print("error %d\n", __LINE__);
	if (xf = i <= f, xf)		print("error %d\n", __LINE__);
	if (xd = i <= d, xd)		print("error %d\n", __LINE__);
	if (xv = i >= v, xv)		print("error %d\n", __LINE__);
	if (xui = i != i7f, xui)	print("error %d\n", __LINE__);
	if (xl = i != ui7f, xl)		print("error %d\n", __LINE__);
	if (xul = i >= l7f, xul)	print("error %d\n", __LINE__);
	if (xf = i >= ul7f, xf)		print("error %d\n", __LINE__);
	if (xd = i <= f7f, xd)		print("error %d\n", __LINE__);
	if (xv = i <= d7f, xv)		print("error %d\n", __LINE__);
	if (xi = i >= v7f, xi)		print("error %d\n", __LINE__);
	if (xl = i <= t52_i, xl)	print("error %d\n", __LINE__);
	if (xul = i >= t52_ui, xul)	print("error %d\n", __LINE__);
	if (xf = i <= t52_l, xf)	print("error %d\n", __LINE__);
	if (xd = i >= t52_ul, xd)	print("error %d\n", __LINE__);
	if (xv = i <= t52_f, xv)	print("error %d\n", __LINE__);
	if (xi = i <= t52_d, xi)	print("error %d\n", __LINE__);
	if (xui = i >= t52_v, xui)	print("error %d\n", __LINE__);
	if (xul = i <= i80, xul)	print("error %d\n", __LINE__);
	if (xf = i >= ui80, xf)		print("error %d\n", __LINE__);
	if (xd = i <= l80, xd)		print("error %d\n", __LINE__);
	if (xv = i >= ul80, xv)		print("error %d\n", __LINE__);
	if (xi = i <= f80, xi)		print("error %d\n", __LINE__);
	if (xui = i <= d80, xui)	print("error %d\n", __LINE__);
	if (xl = i >= v80, xl)		print("error %d\n", __LINE__);
	c_x80();	g_x81();
	if (xf = i != i, xf)		print("error %d\n", __LINE__);
	if (xd = i == ui, xd)		print("error %d\n", __LINE__);
	if (xv = i <= l, xv)		print("error %d\n", __LINE__);
	if (xi = i >= ul, xi)		print("error %d\n", __LINE__);
	if (xui = i >= f, xui)		print("error %d\n", __LINE__);
	if (xl = i >= d, xl)		print("error %d\n", __LINE__);
	if (xul = i >= v, xul)		print("error %d\n", __LINE__);
	if (xd = i != i80, xd)		print("error %d\n", __LINE__);
	if (xv = i == ui80, xv)		print("error %d\n", __LINE__);
	if (xi = i <= l80, xi)		print("error %d\n", __LINE__);
	if (xui = i >= ul80, xui)	print("error %d\n", __LINE__);
	if (xl = i >= f80, xl)		print("error %d\n", __LINE__);
	if (xul = i >= d80, xul)	print("error %d\n", __LINE__);
	if (xf = i >= v80, xf)		print("error %d\n", __LINE__);
	if (xv = i >= t52_i, xv)	print("error %d\n", __LINE__);
	if (xi = i >= t52_ui, xi)	print("error %d\n", __LINE__);
	if (xui = i <= t52_l, xui)	print("error %d\n", __LINE__);
	if (xl = i >= t52_ul, xl)	print("error %d\n", __LINE__);
	if (xul = i >= t52_f, xul)	print("error %d\n", __LINE__);
	if (xf = i >= t52_d, xf)	print("error %d\n", __LINE__);
	if (xd = i >= t52_v, xd)	print("error %d\n", __LINE__);
	if (ci = i >= i81, ci)		print("error %d\n", __LINE__);
	if (cui = i >= ui81, cui)	print("error %d\n", __LINE__);
	if (cl = i <= l81, cl)		print("error %d\n", __LINE__);
	if (cul = i >= ul81, cul)	print("error %d\n", __LINE__);
	if (cf = i >= f81, cf)		print("error %d\n", __LINE__);
	if (cd = i >= d81, cd)		print("error %d\n", __LINE__);
	if (cv = i >= v81, cv)		print("error %d\n", __LINE__);
	c_x7f();	g_x80();
	if (t52_gi = ui != i, t52_gi)		print("error %d\n", __LINE__);
	if (t52_gui = ui != ui, t52_gui)	print("error %d\n", __LINE__);
	if (t52_gl = ui >= l, t52_gl)		print("error %d\n", __LINE__);
	if (t52_gul = ui >= ul, t52_gul)	print("error %d\n", __LINE__);
	if (t52_gf = ui <= f, t52_gf)		print("error %d\n", __LINE__);
	if (t52_gd = ui <= d, t52_gd)		print("error %d\n", __LINE__);
	if (t52_gv = ui >= v, t52_gv)		print("error %d\n", __LINE__);
	c_x7f();
	if (i != 0x7fffffff)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (i <= 0x7fff.0)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (i == 0x80000000)			print("error %d\n", __LINE__);
	if (i > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (i <= 0x8000.0)			print("error %d\n", __LINE__);
	if (i >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (i >= 0x80000001)			print("error %d\n", __LINE__);
	if (i >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (i < 0x8001.0)			print("error %d\n", __LINE__);
	if (i > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ui != 0x7fffffff)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ui <= 0x7fff.0)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ui == 0x80000000)			print("error %d\n", __LINE__);
	if (ui > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ui <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ui >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ui >= 0x80000001)			print("error %d\n", __LINE__);
	if (ui >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ui < 0x8001.0)			print("error %d\n", __LINE__);
	if (ui > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (l <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (l < 0x7fff.0)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (l == 0x80000000)			print("error %d\n", __LINE__);
	if (l > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (l <= 0x8000.0)			print("error %d\n", __LINE__);
	if (l >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (l < 0x80000001)			print("error %d\n", __LINE__);
	if (l > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (l < 0x8001.0)			print("error %d\n", __LINE__);
	if (l > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ul <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (ul > 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ul < 0x7fff.0)			print("error %d\n", __LINE__);
	if (ul > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ul == 0x80000000)			print("error %d\n", __LINE__);
	if (ul > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ul <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ul >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ul < 0x80000001)			print("error %d\n", __LINE__);
	if (ul > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ul < 0x8001.0)			print("error %d\n", __LINE__);
	if (ul > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (f >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (f >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (f != 0x7f.0)			print("error %d\n", __LINE__);
	if (f > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (f == 0x80000000)			print("error %d\n", __LINE__);
	if (f > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (f > 0x80.0)				print("error %d\n", __LINE__);
	if (f >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (f >= 0x80000001)			print("error %d\n", __LINE__);
	if (f >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (f > 0x8001.0)			print("error %d\n", __LINE__);
	if (f > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (d >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (d >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (d != 0x7fff.0)			print("error %d\n", __LINE__);
	if (d > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (d == 0x80000000)			print("error %d\n", __LINE__);
	if (d > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (d > 0x8000.0)			print("error %d\n", __LINE__);
	if (d >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (d >= 0x80000001)			print("error %d\n", __LINE__);
	if (d >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (d > 0x8001.0)			print("error %d\n", __LINE__);
	if (d > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (v < 0x7fffffff)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (v == 0x7f.0)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (v == 0x80000000)			print("error %d\n", __LINE__);
	if (v < 0x8000000000000000)		print("error %d\n", __LINE__);
	if (v <= 0x80.0)			print("error %d\n", __LINE__);
	if (v > 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (v <= 0x80000001)			print("error %d\n", __LINE__);
	if (v <= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (v < 0x8001.0)			print("error %d\n", __LINE__);
	if (v >= 0x800000000000000000000001)	print("error %d\n", __LINE__);
	c_x80();
	if (i >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (i >= 0x7fff.0)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (i == 0x80000000)			print("error %d\n", __LINE__);
	if (i > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (i >= 0x8000.0)			print("error %d\n", __LINE__);
	if (i >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (i >= 0x80000001)			print("error %d\n", __LINE__);
	if (i >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (i > 0x8001.0)			print("error %d\n", __LINE__);
	if (i > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ui <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ui <= 0x7fff.0)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ui != 0x80000000)			print("error %d\n", __LINE__);
	if (ui > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ui <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ui >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ui >= 0x80000001)			print("error %d\n", __LINE__);
	if (ui >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ui < 0x8001.0)			print("error %d\n", __LINE__);
	if (ui > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (l >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (l > 0x7fff.0)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (l == 0x80000000)			print("error %d\n", __LINE__);
	if (l == 0x8000000000000000)		print("error %d\n", __LINE__);
	if (l >= 0x8000.0)			print("error %d\n", __LINE__);
	if (l >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (l > 0x80000001)			print("error %d\n", __LINE__);
	if (l > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (l > 0x8001.0)			print("error %d\n", __LINE__);
	if (l > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ul <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (ul < 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ul < 0x7fff.0)			print("error %d\n", __LINE__);
	if (ul > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ul == 0x80000000)			print("error %d\n", __LINE__);
	if (ul != 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ul <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ul >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ul < 0x80000001)			print("error %d\n", __LINE__);
	if (ul > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ul < 0x8001.0)			print("error %d\n", __LINE__);
	if (ul > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (f >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (f >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (f == 0x7f.0)			print("error %d\n", __LINE__);
	if (f > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (f == 0x80000000)			print("error %d\n", __LINE__);
	if (f == 0x8000000000000000)		print("error %d\n", __LINE__);
	if (f != 0x80.0)			print("error %d\n", __LINE__);
	if (f >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (f >= 0x80000001)			print("error %d\n", __LINE__);
	if (f >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (f > 0x8001.0)			print("error %d\n", __LINE__);
	if (f > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (d >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (d >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (d == 0x7fff.0)			print("error %d\n", __LINE__);
	if (d > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (d == 0x80000000)			print("error %d\n", __LINE__);
	if (d > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (d != 0x8000.0)			print("error %d\n", __LINE__);
	if (d >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (d >= 0x80000001)			print("error %d\n", __LINE__);
	if (d >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (d > 0x8001.0)			print("error %d\n", __LINE__);
	if (d > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (v < 0x7fffffff)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (v == 0x7f.0)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (v == 0x80000000)			print("error %d\n", __LINE__);
	if (v < 0x8000000000000000)		print("error %d\n", __LINE__);
	if (v <= 0x80.0)			print("error %d\n", __LINE__);
	if (v != 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (v <= 0x80000001)			print("error %d\n", __LINE__);
	if (v <= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (v < 0x8001.0)			print("error %d\n", __LINE__);
	if (v >= 0x800000000000000000000001)	print("error %d\n", __LINE__);
	c_x81();
	if (i >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (i >= 0x7fff.0)			print("error %d\n", __LINE__);
	if (i >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (i == 0x80000000)			print("error %d\n", __LINE__);
	if (i > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (i >= 0x8000.0)			print("error %d\n", __LINE__);
	if (i >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (i >= 0x80000001)			print("error %d\n", __LINE__);
	if (i >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (i > 0x8001.0)			print("error %d\n", __LINE__);
	if (i > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ui <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ui <= 0x7fff.0)			print("error %d\n", __LINE__);
	if (ui >= 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ui == 0x80000000)			print("error %d\n", __LINE__);
	if (ui > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ui <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ui >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ui != 0x80000001)			print("error %d\n", __LINE__);
	if (ui >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ui < 0x8001.0)			print("error %d\n", __LINE__);
	if (ui > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (l >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (l > 0x7fff.0)			print("error %d\n", __LINE__);
	if (l > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (l == 0x80000000)			print("error %d\n", __LINE__);
	if (l == 0x8000000000000000)		print("error %d\n", __LINE__);
	if (l >= 0x8000.0)			print("error %d\n", __LINE__);
	if (l >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (l > 0x80000001)			print("error %d\n", __LINE__);
	if (l > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (l > 0x8001.0)			print("error %d\n", __LINE__);
	if (l > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (ul <= 0x7fffffff)			print("error %d\n", __LINE__);
	if (ul < 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (ul < 0x7fff.0)			print("error %d\n", __LINE__);
	if (ul > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (ul == 0x80000000)			print("error %d\n", __LINE__);
	if (ul == 0x8000000000000000)		print("error %d\n", __LINE__);
	if (ul <= 0x8000.0)			print("error %d\n", __LINE__);
	if (ul >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (ul < 0x80000001)			print("error %d\n", __LINE__);
	if (ul > 0x8000000000000001)		print("error %d\n", __LINE__);
	if (ul < 0x8001.0)			print("error %d\n", __LINE__);
	if (ul > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (f >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (f >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (f == 0x7f.0)			print("error %d\n", __LINE__);
	if (f > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (f == 0x80000000)			print("error %d\n", __LINE__);
	if (f == 0x8000000000000000)		print("error %d\n", __LINE__);
	if (f == 0x80.0)			print("error %d\n", __LINE__);
	if (f >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (f >= 0x80000001)			print("error %d\n", __LINE__);
	if (f >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (f > 0x8001.0)			print("error %d\n", __LINE__);
	if (f > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (d >= 0x7fffffff)			print("error %d\n", __LINE__);
	if (d >= 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (d == 0x7fff.0)			print("error %d\n", __LINE__);
	if (d > 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (d == 0x80000000)			print("error %d\n", __LINE__);
	if (d > 0x8000000000000000)		print("error %d\n", __LINE__);
	if (d == 0x8000.0)			print("error %d\n", __LINE__);
	if (d >= 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (d >= 0x80000001)			print("error %d\n", __LINE__);
	if (d >= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (d > 0x8001.0)			print("error %d\n", __LINE__);
	if (d > 0x800000000000000000000001)	print("error %d\n", __LINE__);
	if (v < 0x7fffffff)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffff)		print("error %d\n", __LINE__);
	if (v == 0x7f.0)			print("error %d\n", __LINE__);
	if (v < 0x7fffffffffffffffffffffff)	print("error %d\n", __LINE__);
	if (v == 0x80000000)			print("error %d\n", __LINE__);
	if (v < 0x8000000000000000)		print("error %d\n", __LINE__);
	if (v <= 0x80.0)			print("error %d\n", __LINE__);
	if (v == 0x800000000000000000000000)	print("error %d\n", __LINE__);
	if (v <= 0x80000001)			print("error %d\n", __LINE__);
	if (v <= 0x8000000000000001)		print("error %d\n", __LINE__);
	if (v < 0x8001.0)			print("error %d\n", __LINE__);
	if (v > 0x800000000000000000000001)	print("error %d\n", __LINE__);
    }
} t52_class2 = {};
/* use arguments to force no otimization as it is not done currently */
t52_class2.t0(0x7fffffff, 0x80000001,
	      0x7fffffffffffffff, 0x8000000000000001,
	      0x100.0, 0x1000000.0, 0x8fffffffffffffff);
t52_class2.t1();
t52_class2.t2(0x7fffffff, 0x7fffffff, 0x7fffffffffffffff, 0x7fffffffffffffff,
	      0x7f.0, 0x7fff.0, 0x7fffffffffffffffffffffff,
	      0x80000000, 0x80000000, 0x8000000000000000, 0x8000000000000000,
	      0x80.0, 0x8000.0, 0x800000000000000000000000,
	      0x80000001, 0x80000001, 0x8000000000000001, 0x8000000000000001,
	      0x81.0, 0x8001.0, 0x800000000000000000000001);

/* simple thread tests */
void thread_routine(string_t name)
{
    auto i, j;
    print("%s: enter 0 to 1e6\n", name);
    for (i = 0; i < 5; ++i) {
	for (j = 0; j < 1000000; ++j)
	    ;
	print("%s: 0 to 1e6 %d times\n", name, i + 1);
    }
    print("%s: leave 0 to 1e6\n", name);
}
void thread_routine_with_lots_of_gc_calls(string_t name)
{
    auto i, j, k;
    string_t buffer;
    print("%s: enter 1Mb gc\n", name);
    for (i = 0; i < 5; ++i) {
	for (j = 0; j < 1024; ++j) {
	    buffer = new int8_t[1024];
	    for (k = 0; k < 1024; ++k)
		buffer[k] = k & 0xff;
	}
	print("%s: 1Mb %d times\n", name, i + 1);
    }
    print("%s: leave 1Mb gc\n", name);
}
auto fact_recursive(n)
{
    return n <= 1 ? 1: n * fact_recursive(n - 1);
}
auto fact_sequential(n)
{
    auto r = n;
    while (--n > 1)
	r *= n;
    return r;
}
auto fib_recursive(n)
{
    return n < 2 ? n : fib_recursive(n - 1) + fib_recursive(n - 2);
}
auto fib_cached_rec(n, cache[])
{
    return cache[n] ? cache[n] :
	cache[n] = n < 2 ? n :
	    fib_cached_rec(n - 1, cache) + fib_cached_rec(n - 2, cache);
}
auto fib_cached(n)
{
    return fib_cached_rec(n, new auto[n + 1]);
}
auto fib_sequential(n) {
    auto a = 0, b = 1;
    if (n < 0)		// error
	return n;
    while (n--)
	a = b + (b = a);
    return a;
}
/* should gc frequently due to creating mpz_t objects */
void run_fact_recursive(string_t name)
{
    print("%s: enter fact_recursive\n", name);
    auto i;
    /* guess 100000 times faster than fib_recursive() for the test values */
    for (i = 0; i < 300000; ++i) {
	switch (i & 3) {
	    case 0:
		if (fact_recursive(15) != 1307674368000)
		    print("%s: run_fact_recursive: error %d\n", name, i);
		break;
	    case 2:
		if (fact_recursive(25) != 15511210043330985984000000)
		    print("%s: run_fact_recursive: error %d\n", name, i);
		break;
	    default:
		if (fact_recursive(35) != 10333147966386144929666651337523200000000)
		    print("%s: run_fact_recursive: error %d\n", name, i);
	}
    }
    print("%s: leave fact_recursive\n", name);
}
/* should gc roughly the same amount as fact_recursive, but "surprisingly"
 * it is significantly slower then fact_recursive for large arguments,
 * because fact_recursive actually keeps the result in the vm register,
 * while fact_sequential stores the result in the local variable every
 * iteration, but still, fact_sequential does not do unnecessary allocations,
 * just that it call mpz_set() a lot of times, while in fact_recursive the
 * result value never leaves the vm accumulator */
void run_fact_sequential(string_t name)
{
    print("%s: enter fact_sequential\n", name);
    auto i;
    /* guess 100000 times faster than fib_recursive() for the test values */
    for (i = 0; i < 300000; ++i) {
	switch (i & 3) {
	    case 0:
		if (fact_sequential(15) != 1307674368000)
		    print("%s: run_fact_sequential: error %d\n", name, i);
		break;
	    case 2:
		if (fact_sequential(25) != 15511210043330985984000000)
		    print("%s: run_fact_sequential: error %d\n", name, i);
		break;
	    default:
		if (fact_sequential(35) != 10333147966386144929666651337523200000000)
		    print("%s: run_fact_sequential: error %d\n", name, i);
	}
    }
    print("%s: leave fact_sequential\n", name);
}
/* should never gc due to only working with small integers */
void run_fib_recursive(string_t name)
{
    print("%s: enter fib_recursive\n", name);
    auto i;
    for (i = 0; i < 3; ++i) {
	switch (i & 3) {
	    case 0:
		if (fib_recursive(15) != 610)
		    print("%s: run_fib_recursive: error %d\n", name, i);
		break;
	    case 2:
		if (fib_recursive(25) != 75025)
		    print("%s: run_fib_recursive: error %d\n", name, i);
		break;
	    default:
		if (fib_recursive(35) != 9227465)
		    print("%s: run_fib_recursive: error %d\n", name, i);
	}
    }
    print("%s: leave fib_recursive\n", name);
}
/* should evently gc due to allocating a small buffer per call */
void run_fib_cached(string_t name)
{
    print("%s: enter fib_cached\n", name);
    auto i;
    /* guess 10000 times faster than fib_recursive() for the test values */
    for (i = 0; i < 30000; ++i) {
	switch (i & 3) {
	    case 0:
		if (fib_cached(15) != 610)
		    print("%s: run_fib_cached: error %d\n", name, i);
		break;
	    case 2:
		if (fib_cached(25) != 75025)
		    print("%s: run_fib_cached: error %d\n", name, i);
		break;
	    default:
		if (fib_cached(35) != 9227465)
		    print("%s: run_fib_cached: error %d\n", name, i);
	}
    }
    print("%s: leave fib_cached\n", name);
}
/* should never gc due to only working with small integers
 * this should be faster than fib_cached for most sensible values,
 * as it is not recursive and doesn't do lookups, but fib_cached
 * would be faster if the cache were actually remembered for
 * subsequent calls */
void run_fib_sequential(string_t name)
{
    print("%s: enter fib_sequential\n", name);
    auto i;
    /* guess 100000 times faster than fib_recursive() for the test values */
    for (i = 0; i < 300000; ++i) {
	switch (i & 3) {
	    case 0:
		if (fib_sequential(15) != 610)
		    print("%s: run_fib_sequential: error %d\n", name, i);
		break;
	    case 2:
		if (fib_sequential(25) != 75025)
		    print("%s: run_fib_sequential: error %d\n", name, i);
		break;
	    default:
		if (fib_sequential(35) != 9227465)
		    print("%s: run_fib_sequential: error %d\n", name, i);
	}
    }
    print("%s: leave fib_sequential\n", name);
}
#if 1		/* run as threads */
#define Thread(function, ...)	thread(&function, ## __VA_ARGS__)
#else		/* run sequentially */
#define Thread(function, ...)	function(__VA_ARGS__)
#endif
Thread(thread_routine, " 1");
Thread(thread_routine, " 2");
Thread(thread_routine, " 3");
Thread(thread_routine, " 4");
Thread(thread_routine, " 5");
Thread(thread_routine_with_lots_of_gc_calls, " 6");
Thread(thread_routine_with_lots_of_gc_calls, " 7");
Thread(thread_routine_with_lots_of_gc_calls, " 8");
Thread(thread_routine_with_lots_of_gc_calls, " 9");
Thread(thread_routine_with_lots_of_gc_calls, "10");
Thread(run_fact_recursive, "11");
Thread(run_fact_sequential, "12");
Thread(run_fib_recursive, "13");
Thread(run_fib_cached, "14");
Thread(run_fib_sequential, "15");
Thread(run_fact_recursive, "16");
Thread(run_fact_sequential, "17");
Thread(run_fib_recursive, "18");
Thread(run_fib_cached, "19");
Thread(run_fib_sequential, "20");
/* main thread should be blocked waiting for children threads here,
 * or, just running extra tests, for example, "my default ^R":
 * % cat check/test.e check/math.e | ./econs
 */
